Enum

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.AbstractTypeInferrer.cs (1)

119symbol.Name == nameof(Enum.HasFlag) &&

Commands\GetDocumentCommandWorker.cs (1)

340if (Enum.TryParse<OpenApiSpecVersion>(_context.OpenApiVersion, out var version))

TlsHandshakeFeatureTests.cs (1)

33Assert.True(Enum.IsDefined(typeof(SslProtocols), protocol), "Defined: " + protocol); // Mapping is required, make sure it's current

Linker.Steps\DescriptorMarker.cs (1)

177if (Enum.TryParse(attribute, true, out TypePreserve result))

Linker\Driver.cs (1)

295if (!Enum.TryParse(dependenciesFileFormat, ignoreCase: true, out fileType))

Linker\SerializationMarker.cs (1)

113if (!Enum.IsDefined<SerializerKind>(serializerKind) || serializerKind == SerializerKind.None)

src\tools\illink\src\ILLink.Shared\Annotations.cs (1)

81Enum.GetValues(typeof(DynamicallyAccessedMemberTypes))

src\tools\illink\src\ILLink.Shared\TrimAnalysis\IntrinsicId.cs (1)

210/// <see cref="System.Enum.GetValues(System.Type)"/>

COMAnalyzer.cs (1)

79if (Enum.IsDefined(typeof(UnmanagedType), unmanagedType))

src\tools\illink\src\ILLink.Shared\Annotations.cs (1)

81Enum.GetValues(typeof(DynamicallyAccessedMemberTypes))

src\tools\illink\src\ILLink.Shared\TrimAnalysis\IntrinsicId.cs (1)

210/// <see cref="System.Enum.GetValues(System.Type)"/>

Http3\Http3ConnectionTests.cs (1)

281var f = Enum.Parse<Http3FrameType>(frameType);

Http3\Http3StreamTests.cs (2)

2101var f = Enum.Parse<Http3FrameType>(frameType); 2132var f = Enum.Parse<Http3FrameType>(frameType);

KestrelMetricsTests.cs (1)

34foreach (var reason in Enum.GetValues<ConnectionEndReason>())

src\Shared\Buffers.MemoryPool\MemoryPoolThrowHelper.cs (1)

111Debug.Assert(Enum.IsDefined(typeof(ExceptionArgument), argument), "The enum value is not defined, please check the ExceptionArgument Enum.");

src\Compilers\Core\Portable\InternalUtilities\EnumUtilties.cs (3)

16return (T[])Enum.GetValues(typeof(T)); 20internal static bool ContainsAllValues<T>(int mask) where T : struct, Enum, IConvertible 33internal static bool ContainsValue<T>(T value) where T : struct, Enum

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

181&& Enum.GetUnderlyingType(typeof(TValue)).GetTypeInfo().IsAssignableFrom(Enum.GetUnderlyingType(resultType).GetTypeInfo()))

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (3)

29ImmutableHashSet.CreateRange(Enum.GetValues<OutputKind>()); 146tryParseValue: static (value, out result) => Enum.TryParse(value, ignoreCase: true, result: out result), 166if (Enum.TryParse(kindStr, ignoreCase: true, result: out TEnum kind))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\CodeStyle\CodeStyleOption2`1.cs (1)

188var severity = (DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), severityAttribute.Value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (1)

480capitalizationScheme: (Capitalization)Enum.Parse(typeof(Capitalization), namingStyleElement.Attribute(nameof(CapitalizationScheme)).Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SerializableNamingRule.cs (1)

38EnforcementLevel = ((DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), namingRuleElement.Attribute(nameof(EnforcementLevel))!.Value)).ToReportDiagnostic(),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (5)

310=> (Accessibility)Enum.Parse(typeof(Accessibility), accessibilityElement.Value); 421var symbolKind = (SymbolKind)Enum.Parse(typeof(SymbolKind), symbolKindElement.Value); 433=> new((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value)); 436=> new((MethodKind)Enum.Parse(typeof(MethodKind), methodKindElement.Value)); 536=> new((ModifierKindEnum)Enum.Parse(typeof(ModifierKindEnum), modifierElement.Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (9)

104public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>() where T : struct, Enum 112public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map) where T : struct, Enum 119public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map, ImmutableDictionary<string, T> alternative) where T : struct, Enum 127public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(IEnumerable<(string name, T value)> entries, IEnumerable<(string name, T value)> alternativeEntries) where T : struct, Enum 136public static EditorConfigValueSerializer<T?> CreateSerializerForNullableEnum<T>() where T : struct, Enum 158private static bool TryParseEnum<T>(string str, out T result) where T : struct, Enum 173return Enum.TryParse(str, ignoreCase: true, out result); 209where TFromEnum : struct, Enum 210where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (1)

27=> (SpecialType)Enum.Parse(typeof(SpecialType), arg);

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

144where TFromEnum : struct, Enum 145where TToEnum : struct, Enum

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

17where TFromEnum : struct, Enum 18where TToEnum : struct, Enum

src\Compilers\Core\Portable\InternalUtilities\EnumUtilties.cs (3)

16return (T[])Enum.GetValues(typeof(T)); 20internal static bool ContainsAllValues<T>(int mask) where T : struct, Enum, IConvertible 33internal static bool ContainsValue<T>(T value) where T : struct, Enum

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

181&& Enum.GetUnderlyingType(typeof(TValue)).GetTypeInfo().IsAssignableFrom(Enum.GetUnderlyingType(resultType).GetTypeInfo()))

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (3)

29ImmutableHashSet.CreateRange(Enum.GetValues<OutputKind>()); 146tryParseValue: static (value, out result) => Enum.TryParse(value, ignoreCase: true, result: out result), 166if (Enum.TryParse(kindStr, ignoreCase: true, result: out TEnum kind))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\CodeStyle\CodeStyleOption2`1.cs (1)

188var severity = (DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), severityAttribute.Value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (1)

480capitalizationScheme: (Capitalization)Enum.Parse(typeof(Capitalization), namingStyleElement.Attribute(nameof(CapitalizationScheme)).Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SerializableNamingRule.cs (1)

38EnforcementLevel = ((DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), namingRuleElement.Attribute(nameof(EnforcementLevel))!.Value)).ToReportDiagnostic(),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (5)

310=> (Accessibility)Enum.Parse(typeof(Accessibility), accessibilityElement.Value); 421var symbolKind = (SymbolKind)Enum.Parse(typeof(SymbolKind), symbolKindElement.Value); 433=> new((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value)); 436=> new((MethodKind)Enum.Parse(typeof(MethodKind), methodKindElement.Value)); 536=> new((ModifierKindEnum)Enum.Parse(typeof(ModifierKindEnum), modifierElement.Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (9)

104public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>() where T : struct, Enum 112public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map) where T : struct, Enum 119public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map, ImmutableDictionary<string, T> alternative) where T : struct, Enum 127public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(IEnumerable<(string name, T value)> entries, IEnumerable<(string name, T value)> alternativeEntries) where T : struct, Enum 136public static EditorConfigValueSerializer<T?> CreateSerializerForNullableEnum<T>() where T : struct, Enum 158private static bool TryParseEnum<T>(string str, out T result) where T : struct, Enum 173return Enum.TryParse(str, ignoreCase: true, out result); 209where TFromEnum : struct, Enum 210where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (1)

27=> (SpecialType)Enum.Parse(typeof(SpecialType), arg);

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

144where TFromEnum : struct, Enum 145where TToEnum : struct, Enum

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

17where TFromEnum : struct, Enum 18where TToEnum : struct, Enum

ApiLifecycle\Model\Field.cs (1)

20_ = Enum.TryParse<Stage>(enumString, out var stage);

ApiLifecycle\Model\Method.cs (1)

20if (Enum.TryParse<Stage>(enumString, out var stage))

ApiLifecycle\Model\Prop.cs (1)

20_ = Enum.TryParse<Stage>(stageString, out var stage);

ApiLifecycle\Model\TypeDef.cs (1)

24_ = Enum.TryParse<Stage>(value[nameof(Stage)].AsString, out var stage);

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

RouteEmbeddedLanguage\Infrastructure\EmbeddedLanguageCommentOptions.cs (1)

22internal static class EmbeddedLanguageCommentOptions<TOptions> where TOptions : struct, Enum

Infrastructure\WellKnownTypesTests.cs (1)

117var wellKnownTypeKeys = Enum.GetValues<WellKnownType>();

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

OpenIdConnectConfigureOptions.cs (2)

102? Enum.Parse<SameSiteMode>(sameSiteMode, ignoreCase: true) 105? Enum.Parse<CookieSecurePolicy>(securePolicy, ignoreCase: true)

BindConverter.cs (6)

1604private static bool ConvertToEnum<T>(object? obj, CultureInfo? _, out T value) where T : struct, Enum 1613if (!Enum.TryParse<T>(text, out var converted)) 1619if (!Enum.IsDefined(typeof(T), converted)) 1629private static bool ConvertToNullableEnum<T>(object? obj, CultureInfo? _, out T? value) where T : struct, Enum 1638if (!Enum.TryParse<T>(text, out var converted)) 1644if (!Enum.IsDefined(typeof(T), converted))

FormMapping\Converters\EnumConverter.cs (2)

9internal class EnumConverter<TEnum> : FormDataConverter<TEnum>, ISingleValueConverter<TEnum> where TEnum : struct, Enum 15if (Enum.TryParse(value, ignoreCase: true, out result))

Forms\InputRadioTest.cs (2)

78foreach (var selectedValue in (TestEnum[])Enum.GetValues(typeof(TestEnum))) 94foreach (var value in (TestEnum[])Enum.GetValues(typeof(TestEnum)))

IpcCommon.cs (1)

45messageType = (T)Enum.Parse(typeof(T), parsed[0].GetString());

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

50defaultValue = Enum.ToObject(underlyingType, defaultValue);

AuthenticatedEncryption\ConfigurationModel\AuthenticatedEncryptorDescriptorDeserializer.cs (2)

34configuration.EncryptionAlgorithm = (EncryptionAlgorithm)Enum.Parse(typeof(EncryptionAlgorithm), (string)encryptionElement.Attribute("algorithm")!); 40configuration.ValidationAlgorithm = (ValidationAlgorithm)Enum.Parse(typeof(ValidationAlgorithm), (string)validationElement.Attribute("algorithm")!);

HealthCheckOptions.cs (1)

52var missingHealthStatus = Enum.GetValues<HealthStatus>().Except(mapping.Keys).ToList();

GrpcJsonSettings.cs (1)

19/// Gets or sets a value that indicates whether <see cref="Enum"/> values are written as integers instead of strings.

Internal\Json\EnumConverter.cs (1)

12internal sealed class EnumConverter<TEnum> : SettingsConverterBase<TEnum> where TEnum : Enum

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

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

50defaultValue = Enum.ToObject(underlyingType, defaultValue);

HttpConnection.cs (1)

367if (!Enum.TryParse<HttpTransportType>(transport.Transport, out var transportType))

HttpConnectionDispatcherTests.cs (1)

278var transportType = (HttpTransportType)Enum.Parse(typeof(HttpTransportType), transport.Value<string>("transport"));

WebSocketsTests.cs (2)

49messageType: (WebSocketMessageType)Enum.Parse(typeof(WebSocketMessageType), webSocketMessageType), 105Assert.Equal((WebSocketMessageType)Enum.Parse(typeof(WebSocketMessageType), expectedMessageType), clientSummary.Received[0].MessageType);

RequestDelegateFactory.cs (1)

2001converted = Enum.ToObject(targetType, defaultValue);

src\Components\Endpoints\src\FormMapping\Converters\EnumConverter.cs (2)

9internal class EnumConverter<TEnum> : FormDataConverter<TEnum>, ISingleValueConverter<TEnum> where TEnum : struct, Enum 15if (Enum.TryParse(value, ignoreCase: true, out result))

src\Shared\ParameterBindingMethodCache.cs (4)

510methodInfo = typeof(Enum).GetMethod( 511nameof(Enum.TryParse), 517methodInfo = typeof(Enum).GetMethod( 518nameof(Enum.TryParse),

IdentityBuilderUIExtensions.cs (2)

95if (!Enum.TryParse(metadata, ignoreCase: true, out uiFramework)) 97var enumValues = string.Join(", ", Enum.GetNames(typeof(UIFramework)).Select(v => $"'{v}'"));

Operations\OperationBase.cs (1)

37if (!Enum.TryParse(value, ignoreCase: true, result: out result))

Operations\OperationBase.cs (1)

37if (!Enum.TryParse(value, ignoreCase: true, result: out result))

ModelBinding\ModelMetadata.cs (6)

263/// Gets the ordered and grouped display names and values of all <see cref="Enum"/> values in 268/// <see cref="Enum"/> field groups, names and values. <c>null</c> if <see cref="IsEnum"/> is <c>false</c>. 273/// Gets the names and values of all <see cref="Enum"/> values in <see cref="UnderlyingOrModelType"/>. 276/// An <see cref="IReadOnlyDictionary{String, String}"/> of mappings between <see cref="Enum"/> field names 327/// Gets a value indicating whether <see cref="UnderlyingOrModelType"/> is for an <see cref="Enum"/>. 336/// Gets a value indicating whether <see cref="UnderlyingOrModelType"/> is for an <see cref="Enum"/> with an

src\Shared\ParameterBindingMethodCache.cs (4)

510methodInfo = typeof(Enum).GetMethod( 511nameof(Enum.TryParse), 517methodInfo = typeof(Enum).GetMethod( 518nameof(Enum.TryParse),

ModelBinding\Binders\EnumTypeModelBinder.cs (3)

12/// <see cref="IModelBinder"/> implementation to bind models for types deriving from <see cref="Enum"/>. 82Enum.GetUnderlyingType(modelType), 87return Enum.IsDefined(modelType, model);

ModelBinding\Binders\EnumTypeModelBinderProvider.cs (1)

12/// A <see cref="IModelBinderProvider"/> for types deriving from <see cref="Enum"/>.

ModelBinding\Metadata\DisplayMetadata.cs (4)

141/// Gets the ordered and grouped display names and values of all <see cref="System.Enum"/> values in 148/// Gets the names and values of all <see cref="System.Enum"/> values in 174/// <see cref="System.Enum"/>. See <see cref="ModelMetadata.IsEnum"/>. 181/// <see cref="System.Enum"/> with an associated <see cref="System.FlagsAttribute"/>. See

ModelBinding\ModelBindingHelper.cs (1)

711return Enum.ToObject(destinationType, value);

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

50defaultValue = Enum.ToObject(underlyingType, defaultValue);

DataAnnotationsMetadataProvider.cs (2)

184var enumFields = Enum.GetNames(underlyingType) 191var value = ((Enum)field.GetValue(obj: null)!).ToString("d");

DefaultHtmlGenerator.cs (7)

986var enumValue = value as Enum; 999enumValue = (Enum)methodInfo.Invoke(obj: null, parameters: new[] { stringValue }); 1383private static Enum ConvertEnumFromInteger(object value, Type targetType) 1387return (Enum)Enum.ToObject(targetType, value); 1399if (Enum.TryParse(value, out TEnum enumValue))

HtmlHelper.cs (4)

374nameof(Enum).ToLowerInvariant(), 392nameof(Enum).ToLowerInvariant(), 1365/// Thrown if <paramref name="metadata"/>'s <see cref="ModelMetadata.ModelType"/> is not an <see cref="Enum"/> 1376nameof(Enum).ToLowerInvariant(),

IHtmlGenerator.cs (3)

585/// If the <paramref name="expression"/> result or the element type is an <see cref="System.Enum"/>, returns a 586/// <see cref="string"/> containing the integer representation of the <see cref="System.Enum"/> value as well 587/// as all <see cref="System.Enum"/> names for that value. Otherwise returns the default <see cref="string"/>

Infrastructure\DefaultTempDataSerializer.cs (1)

158case Enum _:

ModelExplorerExtensions.cs (1)

48if (modelExplorer.Metadata.IsEnum && modelExplorer.Model is Enum modelEnum)

Rendering\IHtmlHelper.cs (2)

380/// Thrown if <typeparamref name="TEnum"/> is not an <see cref="Enum"/> or if it has a 394/// Thrown if <paramref name="enumType"/> is not an <see cref="Enum"/> or if it has a

TemplateBuilder.cs (1)

102else if (viewData.ModelMetadata.IsEnum && _model is Enum modelEnum)

TemplateRendererTest.cs (1)

28{ typeof(Enum), new string[] { "Enum", "String" } },

Extensions\JsonNodeSchemaExtensions.cs (1)

498if (Enum.TryParse<JsonSchemaType>(jsonNode?.GetValue<string>(), true, out var openApiSchemaType))

Schemas\OpenApiJsonSchema.Helpers.cs (3)

194schema.Type |= Enum.Parse<JsonSchemaType>(type, ignoreCase: true); 198schema.Type = Enum.Parse<JsonSchemaType>(type, ignoreCase: true); 206schema.Type = Enum.Parse<JsonSchemaType>(type, ignoreCase: true);

src\Shared\ParameterBindingMethodCache.cs (4)

510methodInfo = typeof(Enum).GetMethod( 511nameof(Enum.TryParse), 517methodInfo = typeof(Enum).GetMethod( 518nameof(Enum.TryParse),

IISUrlRewrite\UrlRewriteFileParser.cs (1)

277else if (!Enum.TryParse(attribute.Value, ignoreCase: true, result: out enumResult))

src\Shared\Buffers.MemoryPool\MemoryPoolThrowHelper.cs (1)

111Debug.Assert(Enum.IsDefined(typeof(ExceptionArgument), argument), "The enum value is not defined, please check the ExceptionArgument Enum.");

HttpsTests.cs (1)

166Assert.True(Enum.IsDefined(typeof(SslProtocols), protocol), "Defined: " + protocol); // Mapping is required, make sure it's current

src\Shared\Buffers.MemoryPool\MemoryPoolThrowHelper.cs (1)

111Debug.Assert(Enum.IsDefined(typeof(ExceptionArgument), argument), "The enum value is not defined, please check the ExceptionArgument Enum.");

Internal\Certificates\CertificateConfigLoader.cs (1)

332storeLocation = (StoreLocation)Enum.Parse(typeof(StoreLocation), location, ignoreCase: true);

Internal\ConfigurationReader.cs (3)

168if (Enum.TryParse<ClientCertificateMode>(clientCertificateMode, ignoreCase: true, out var result)) 178if (Enum.TryParse<HttpProtocols>(protocols, ignoreCase: true, out var result)) 202if (Enum.TryParse(current, ignoreCase: true, out SslProtocols parsed))

Internal\ThrowHelper.cs (1)

24Debug.Assert(Enum.IsDefined(typeof(ExceptionArgument), argument), "The enum value is not defined, please check the ExceptionArgument Enum.");

src\Shared\Buffers.MemoryPool\MemoryPoolThrowHelper.cs (1)

111Debug.Assert(Enum.IsDefined(typeof(ExceptionArgument), argument), "The enum value is not defined, please check the ExceptionArgument Enum.");

src\Shared\Buffers.MemoryPool\MemoryPoolThrowHelper.cs (1)

111Debug.Assert(Enum.IsDefined(typeof(ExceptionArgument), argument), "The enum value is not defined, please check the ExceptionArgument Enum.");

src\Shared\Buffers.MemoryPool\MemoryPoolThrowHelper.cs (1)

111Debug.Assert(Enum.IsDefined(typeof(ExceptionArgument), argument), "The enum value is not defined, please check the ExceptionArgument Enum.");

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

50defaultValue = Enum.ToObject(underlyingType, defaultValue);

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

Autobahn\AutobahnServerResult.cs (1)

27Server = (ServerType)Enum.Parse(typeof(ServerType), splat[0]);

BinaryTranslator.cs (3)

529where T : struct, Enum 533value = (T)Enum.ToObject(enumType, numericValue); 1337where T : struct, Enum

ITranslator.cs (1)

291where T : struct, Enum;

Polyfills\StringSyntaxAttribute.cs (1)

43/// <summary>The syntax identifier for strings containing <see cref="Enum"/> format specifiers.</summary>

src\Dependencies\Contracts\EnumExtensions.cs (4)

12public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 13=> Enum.GetValues<TEnum>(); 15public static string[] GetNames<TEnum>() where TEnum : struct, Enum 16=> Enum.GetNames<TEnum>();

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

Differs\Differences.cs (2)

32Enum en = obj as Enum;

InternalUtilities\EnumUtilties.cs (3)

16return (T[])Enum.GetValues(typeof(T)); 20internal static bool ContainsAllValues<T>(int mask) where T : struct, Enum, IConvertible 33internal static bool ContainsValue<T>(T value) where T : struct, Enum

InternalUtilities\JsonWriter.cs (3)

109public void Write<T>(string key, T value) where T : struct, Enum 195public void Write<T>(T value) where T : struct, Enum 200public void Write<T>(T? value) where T : struct, Enum

SpecialType.cs (1)

36/// Indicates that the type is <see cref="Enum"/>.

src\Dependencies\Contracts\EnumExtensions.cs (4)

12public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 13=> Enum.GetValues<TEnum>(); 15public static string[] GetNames<TEnum>() where TEnum : struct, Enum 16=> Enum.GetNames<TEnum>();

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer.cs (2)

1131Enum.TryParse(fieldReference.Field.Name, out DiagnosticSeverity parsedSeverity)) 1142Enum.TryParse(fieldReference2.Field.Name, out RuleLevel parsedRuleLevel))

MetaAnalyzers\ReleaseTrackingHelper.cs (1)

296if (Enum.TryParse(severityPart, ignoreCase: true, out DiagnosticSeverity parsedSeverity))

src\Compilers\Core\Portable\InternalUtilities\EnumUtilties.cs (3)

16return (T[])Enum.GetValues(typeof(T)); 20internal static bool ContainsAllValues<T>(int mask) where T : struct, Enum, IConvertible 33internal static bool ContainsValue<T>(T value) where T : struct, Enum

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

181&& Enum.GetUnderlyingType(typeof(TValue)).GetTypeInfo().IsAssignableFrom(Enum.GetUnderlyingType(resultType).GetTypeInfo()))

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (3)

29ImmutableHashSet.CreateRange(Enum.GetValues<OutputKind>()); 146tryParseValue: static (value, out result) => Enum.TryParse(value, ignoreCase: true, result: out result), 166if (Enum.TryParse(kindStr, ignoreCase: true, result: out TEnum kind))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\CodeStyle\CodeStyleOption2`1.cs (1)

188var severity = (DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), severityAttribute.Value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (1)

480capitalizationScheme: (Capitalization)Enum.Parse(typeof(Capitalization), namingStyleElement.Attribute(nameof(CapitalizationScheme)).Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SerializableNamingRule.cs (1)

38EnforcementLevel = ((DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), namingRuleElement.Attribute(nameof(EnforcementLevel))!.Value)).ToReportDiagnostic(),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (5)

310=> (Accessibility)Enum.Parse(typeof(Accessibility), accessibilityElement.Value); 421var symbolKind = (SymbolKind)Enum.Parse(typeof(SymbolKind), symbolKindElement.Value); 433=> new((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value)); 436=> new((MethodKind)Enum.Parse(typeof(MethodKind), methodKindElement.Value)); 536=> new((ModifierKindEnum)Enum.Parse(typeof(ModifierKindEnum), modifierElement.Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (9)

104public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>() where T : struct, Enum 112public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map) where T : struct, Enum 119public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map, ImmutableDictionary<string, T> alternative) where T : struct, Enum 127public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(IEnumerable<(string name, T value)> entries, IEnumerable<(string name, T value)> alternativeEntries) where T : struct, Enum 136public static EditorConfigValueSerializer<T?> CreateSerializerForNullableEnum<T>() where T : struct, Enum 158private static bool TryParseEnum<T>(string str, out T result) where T : struct, Enum 173return Enum.TryParse(str, ignoreCase: true, out result); 209where TFromEnum : struct, Enum 210where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (1)

27=> (SpecialType)Enum.Parse(typeof(SpecialType), arg);

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

144where TFromEnum : struct, Enum 145where TToEnum : struct, Enum

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

17where TFromEnum : struct, Enum 18where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.AbstractTypeInferrer.cs (1)

119symbol.Name == nameof(Enum.HasFlag) &&

src\Compilers\Core\Portable\InternalUtilities\EnumUtilties.cs (3)

16return (T[])Enum.GetValues(typeof(T)); 20internal static bool ContainsAllValues<T>(int mask) where T : struct, Enum, IConvertible 33internal static bool ContainsValue<T>(T value) where T : struct, Enum

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

181&& Enum.GetUnderlyingType(typeof(TValue)).GetTypeInfo().IsAssignableFrom(Enum.GetUnderlyingType(resultType).GetTypeInfo()))

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (3)

29ImmutableHashSet.CreateRange(Enum.GetValues<OutputKind>()); 146tryParseValue: static (value, out result) => Enum.TryParse(value, ignoreCase: true, result: out result), 166if (Enum.TryParse(kindStr, ignoreCase: true, result: out TEnum kind))

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PropertySetAnalysis\PropertySetAbstractValue.ValuePool.cs (1)

29int[] values = Enum.GetValues<PropertySetAbstractValueKind>().Cast<int>().ToArray();

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\TaintedDataConfig.cs (1)

114foreach (var sinkKind in Enum.GetValues<SinkKind>())

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\CodeStyle\CodeStyleOption2`1.cs (1)

188var severity = (DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), severityAttribute.Value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (1)

480capitalizationScheme: (Capitalization)Enum.Parse(typeof(Capitalization), namingStyleElement.Attribute(nameof(CapitalizationScheme)).Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SerializableNamingRule.cs (1)

38EnforcementLevel = ((DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), namingRuleElement.Attribute(nameof(EnforcementLevel))!.Value)).ToReportDiagnostic(),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (5)

310=> (Accessibility)Enum.Parse(typeof(Accessibility), accessibilityElement.Value); 421var symbolKind = (SymbolKind)Enum.Parse(typeof(SymbolKind), symbolKindElement.Value); 433=> new((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value)); 436=> new((MethodKind)Enum.Parse(typeof(MethodKind), methodKindElement.Value)); 536=> new((ModifierKindEnum)Enum.Parse(typeof(ModifierKindEnum), modifierElement.Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (9)

104public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>() where T : struct, Enum 112public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map) where T : struct, Enum 119public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map, ImmutableDictionary<string, T> alternative) where T : struct, Enum 127public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(IEnumerable<(string name, T value)> entries, IEnumerable<(string name, T value)> alternativeEntries) where T : struct, Enum 136public static EditorConfigValueSerializer<T?> CreateSerializerForNullableEnum<T>() where T : struct, Enum 158private static bool TryParseEnum<T>(string str, out T result) where T : struct, Enum 173return Enum.TryParse(str, ignoreCase: true, out result); 209where TFromEnum : struct, Enum 210where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (1)

27=> (SpecialType)Enum.Parse(typeof(SpecialType), arg);

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

144where TFromEnum : struct, Enum 145where TToEnum : struct, Enum

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

17where TFromEnum : struct, Enum 18where TToEnum : struct, Enum

src\Compilers\Core\Portable\InternalUtilities\EnumUtilties.cs (3)

16return (T[])Enum.GetValues(typeof(T)); 20internal static bool ContainsAllValues<T>(int mask) where T : struct, Enum, IConvertible 33internal static bool ContainsValue<T>(T value) where T : struct, Enum

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

181&& Enum.GetUnderlyingType(typeof(TValue)).GetTypeInfo().IsAssignableFrom(Enum.GetUnderlyingType(resultType).GetTypeInfo()))

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (3)

29ImmutableHashSet.CreateRange(Enum.GetValues<OutputKind>()); 146tryParseValue: static (value, out result) => Enum.TryParse(value, ignoreCase: true, result: out result), 166if (Enum.TryParse(kindStr, ignoreCase: true, result: out TEnum kind))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\CodeStyle\CodeStyleOption2`1.cs (1)

188var severity = (DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), severityAttribute.Value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (1)

480capitalizationScheme: (Capitalization)Enum.Parse(typeof(Capitalization), namingStyleElement.Attribute(nameof(CapitalizationScheme)).Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SerializableNamingRule.cs (1)

38EnforcementLevel = ((DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), namingRuleElement.Attribute(nameof(EnforcementLevel))!.Value)).ToReportDiagnostic(),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (5)

310=> (Accessibility)Enum.Parse(typeof(Accessibility), accessibilityElement.Value); 421var symbolKind = (SymbolKind)Enum.Parse(typeof(SymbolKind), symbolKindElement.Value); 433=> new((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value)); 436=> new((MethodKind)Enum.Parse(typeof(MethodKind), methodKindElement.Value)); 536=> new((ModifierKindEnum)Enum.Parse(typeof(ModifierKindEnum), modifierElement.Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (9)

104public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>() where T : struct, Enum 112public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map) where T : struct, Enum 119public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map, ImmutableDictionary<string, T> alternative) where T : struct, Enum 127public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(IEnumerable<(string name, T value)> entries, IEnumerable<(string name, T value)> alternativeEntries) where T : struct, Enum 136public static EditorConfigValueSerializer<T?> CreateSerializerForNullableEnum<T>() where T : struct, Enum 158private static bool TryParseEnum<T>(string str, out T result) where T : struct, Enum 173return Enum.TryParse(str, ignoreCase: true, out result); 209where TFromEnum : struct, Enum 210where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (1)

27=> (SpecialType)Enum.Parse(typeof(SpecialType), arg);

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

144where TFromEnum : struct, Enum 145where TToEnum : struct, Enum

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

17where TFromEnum : struct, Enum 18where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.AbstractTypeInferrer.cs (1)

119symbol.Name == nameof(Enum.HasFlag) &&

src\Analyzers\Core\Analyzers\ForEachCast\AbstractForEachCastDiagnosticAnalyzer.cs (1)

22where TSyntaxKind : struct, Enum

src\Analyzers\Core\Analyzers\MakeFieldReadonly\AbstractMakeFieldReadonlyDiagnosticAnalyzer.cs (1)

24where TSyntaxKind : struct, Enum

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\SuppressMessageAttributeState.cs (1)

29foreach (var targetScope in Enum.GetValues<TargetScope>())

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (1)

37where TSyntaxKind : struct, Enum

src\Compilers\Core\Portable\InternalUtilities\EnumUtilties.cs (3)

16return (T[])Enum.GetValues(typeof(T)); 20internal static bool ContainsAllValues<T>(int mask) where T : struct, Enum, IConvertible 33internal static bool ContainsValue<T>(T value) where T : struct, Enum

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\CodeStyle\CodeStyleOption2`1.cs (1)

188var severity = (DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), severityAttribute.Value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (1)

480capitalizationScheme: (Capitalization)Enum.Parse(typeof(Capitalization), namingStyleElement.Attribute(nameof(CapitalizationScheme)).Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SerializableNamingRule.cs (1)

38EnforcementLevel = ((DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), namingRuleElement.Attribute(nameof(EnforcementLevel))!.Value)).ToReportDiagnostic(),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (5)

310=> (Accessibility)Enum.Parse(typeof(Accessibility), accessibilityElement.Value); 421var symbolKind = (SymbolKind)Enum.Parse(typeof(SymbolKind), symbolKindElement.Value); 433=> new((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value)); 436=> new((MethodKind)Enum.Parse(typeof(MethodKind), methodKindElement.Value)); 536=> new((ModifierKindEnum)Enum.Parse(typeof(ModifierKindEnum), modifierElement.Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (9)

104public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>() where T : struct, Enum 112public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map) where T : struct, Enum 119public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map, ImmutableDictionary<string, T> alternative) where T : struct, Enum 127public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(IEnumerable<(string name, T value)> entries, IEnumerable<(string name, T value)> alternativeEntries) where T : struct, Enum 136public static EditorConfigValueSerializer<T?> CreateSerializerForNullableEnum<T>() where T : struct, Enum 158private static bool TryParseEnum<T>(string str, out T result) where T : struct, Enum 173return Enum.TryParse(str, ignoreCase: true, out result); 209where TFromEnum : struct, Enum 210where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (1)

27=> (SpecialType)Enum.Parse(typeof(SpecialType), arg);

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

144where TFromEnum : struct, Enum 145where TToEnum : struct, Enum

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

17where TFromEnum : struct, Enum 18where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.AbstractTypeInferrer.cs (1)

119symbol.Name == nameof(Enum.HasFlag) &&

src\Dependencies\Contracts\EnumExtensions.cs (4)

12public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 13=> Enum.GetValues<TEnum>(); 15public static string[] GetNames<TEnum>() where TEnum : struct, Enum 16=> Enum.GetNames<TEnum>();

EnumExtensions.cs (4)

12public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 13=> Enum.GetValues<TEnum>(); 15public static string[] GetNames<TEnum>() where TEnum : struct, Enum 16=> Enum.GetNames<TEnum>();

CommandLine\CSharpCompiler.cs (1)

287foreach (var v in (LanguageVersion[])Enum.GetValues(typeof(LanguageVersion)))

Compilation\CSharpCompilerDiagnosticAnalyzer.cs (1)

23var errorCodes = Enum.GetValues(typeof(ErrorCode));

SymbolDisplay\ObjectDisplay.cs (1)

47type = Enum.GetUnderlyingType(type);

Syntax\SyntaxKindFacts.cs (6)

22Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i)); 151Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i)); 181Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i)); 187Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i)); 193Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i)); 1241Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i));

src\Analyzers\CSharp\CodeFixes\UseUtf8StringLiteral\UseUtf8StringLiteralCodeFixProvider.cs (1)

101if (!Enum.TryParse(operationLocationString, out UseUtf8StringLiteralDiagnosticAnalyzer.ArrayCreationOperationLocation operationLocation))

CommandLineTests.cs (3)

1732Enum.GetValues(typeof(LanguageVersion)).Cast<LanguageVersion>().Select(v => v.ToDisplayString())); 1739var versions = Enum.GetValues(typeof(LanguageVersion)) 1880var expected = Enum.GetValues(typeof(LanguageVersion)).Cast<LanguageVersion>()

Completion\CompletionProviders\ExtensionMethodImportCompletionProviderTests.cs (1)

44foreach (var refKind in Enum.GetValues<ReferenceType>())

LanguageServer\CSharpLspBuildOnlyDiagnosticsTests.cs (1)

24var errorCodes = Enum.GetValues<ErrorCode>();

Attributes\AttributeTests_Synthesized.cs (3)

39foreach (var level in Enum.GetValues(typeof(OptimizationLevel))) 50foreach (var kind in Enum.GetValues(typeof(OutputKind))) 52foreach (var level in Enum.GetValues(typeof(OptimizationLevel)))

Diagnostics\DiagnosticAnalyzerTests.cs (1)

728var missingResource = Enum.GetName(typeof(ErrorCode), id) + "_Title";

Diagnostics\DiagnosticSuppressorTests.cs (1)

327var severities = Enum.GetValues(typeof(DiagnosticSeverity));

src\Compilers\CSharp\Portable\SymbolDisplay\ObjectDisplay.cs (1)

47type = Enum.GetUnderlyingType(type);

src\Compilers\CSharp\Portable\Syntax\SyntaxKindFacts.cs (6)

22Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i)); 151Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i)); 181Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i)); 187Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i)); 193Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i)); 1241Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i));

src\Analyzers\CSharp\CodeFixes\UseUtf8StringLiteral\UseUtf8StringLiteralCodeFixProvider.cs (1)

101if (!Enum.TryParse(operationLocationString, out UseUtf8StringLiteralDiagnosticAnalyzer.ArrayCreationOperationLocation operationLocation))

Diagnostics\Suppression\RemoveUnnecessaryPragmaSuppressionsTests.cs (1)

139var errorCodes = Enum.GetValues<ErrorCode>();

EditAndContinue\CSharpEditAndContinueAnalyzerTests.cs (1)

90foreach (var kind in Enum.GetValues<SyntaxKind>().Where(hasLabel))

CommandLineRunnerTests.cs (1)

765var expected = Enum.GetValues<LanguageVersion>()

InteractiveSessionTests.cs (1)

246Assert.Equal(typeof(int), Enum.GetUnderlyingType(e.GetType()));

Semantics\NullableReferenceTypesTests.cs (5)

125152foreach (ReportDiagnostic option in Enum.GetValues(typeof(ReportDiagnostic))) 125335foreach (ReportDiagnostic option in Enum.GetValues(typeof(ReportDiagnostic))) 126120foreach (ReportDiagnostic option in Enum.GetValues(typeof(ReportDiagnostic))) 126876private static readonly NullableAnnotation[] s_AllNullableAnnotations = ((NullableAnnotation[])Enum.GetValues(typeof(NullableAnnotation))).Where(n => n != NullableAnnotation.Ignored).ToArray(); 126877private static readonly NullableFlowState[] s_AllNullableFlowStates = (NullableFlowState[])Enum.GetValues(typeof(NullableFlowState));

SourceGeneration\GeneratorDriverTests.cs (2)

3236foreach (IncrementalGeneratorOutputKind kind in Enum.GetValues(typeof(IncrementalGeneratorOutputKind))) 3264bool isTextForKind(GeneratedSourceResult s) => s.HintName == Enum.GetName(typeof(IncrementalGeneratorOutputKind), kind) + ".cs";

Compilation\CSharpCompilationOptionsTests.cs (1)

456var values = (NullableContextOptions[])System.Enum.GetValues(typeof(NullableContextOptions));

Compilation\GetUnusedImportDirectivesTests.cs (1)

485foreach (DocumentationMode documentationMode in Enum.GetValues(typeof(DocumentationMode)))

Symbols\MissingSpecialMember.cs (2)

552foreach (SpecialMember special in Enum.GetValues(typeof(SpecialMember))) 945foreach (WellKnownMember wkm in Enum.GetValues(typeof(WellKnownMember)))

Symbols\Source\ClsComplianceTests.cs (1)

3158foreach (SpecialType st in Enum.GetValues(typeof(SpecialType)))

Diagnostics\DiagnosticTest.cs (6)

39foreach (ErrorCode code in Enum.GetValues(typeof(ErrorCode))) 56var values = Enum.GetValues(typeof(ErrorCode)); 214foreach (ErrorCode errorCode in Enum.GetValues(typeof(ErrorCode))) 247foreach (ErrorCode errorCode in Enum.GetValues(typeof(ErrorCode))) 498foreach (ErrorCode error in Enum.GetValues(typeof(ErrorCode))) 2937foreach (ErrorCode errorCode in Enum.GetValues(typeof(ErrorCode)))

Parsing\AsyncParsingTests.cs (1)

31foreach (LanguageVersion version in Enum.GetValues(typeof(LanguageVersion)))

Parsing\LanguageVersionTests.cs (1)

18var highest = Enum.

Syntax\SyntaxTests.cs (3)

259foreach (var kind in (SyntaxKind[])Enum.GetValues(typeof(SyntaxKind))) 292Assert.True(Enum.IsDefined(typeof(SyntaxKind), kind), $"Nonexistent kind '{kind}' returned from method '{method.Name}'"); 314if (Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i))

Metadata\WinMdEventTests.cs (1)

2912foreach (OutputKind kind in Enum.GetValues(typeof(OutputKind)))

Workspace\LanguageServices\CSharpCompilationFactoryService.cs (1)

48!Enum.TryParse<OutputKind>(outputKindString, out var outputKind))

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

EditorConfigSettings\Data\CodeStyleSetting.cs (2)

100where T : Enum 114where T : Enum

EditorConfigSettings\Data\EnumFlagsSetting.cs (1)

20where TOptionValue : struct, Enum

EditorConfigSettings\Data\Setting.cs (1)

74where TValue : struct, Enum

InlineRename\InlineRenameSession.cs (1)

390m["Kind"] = Enum.GetName(typeof(WorkspaceChangeKind), args.Kind);

Logging\FunctionIdOptions.cs (1)

38=> Enum.GetValues<FunctionId>();

EditorConfigSettings\Data\CodeStyleSettingsTest.cs (3)

69enumValues: Enum.GetValues<DayOfWeek>(), 70valueDescriptions: Enum.GetNames<DayOfWeek>()); 91where T : notnull, Enum

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

36/// Indicates that the type is <see cref="Enum"/>.

src\Compilers\CSharp\Portable\Syntax\SyntaxKindFacts.cs (6)

22Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i)); 151Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i)); 181Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i)); 187Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i)); 193Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i)); 1241Debug.Assert(Enum.IsDefined(typeof(SyntaxKind), (SyntaxKind)i));

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

ResultProviderTestBase.cs (1)

480private static string FormatEnumValue(Enum e)

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

FSharpGlyphTests.cs (2)

18foreach (var number in Enum.GetValues(typeof(FSharpGlyph))) 26foreach (var number in Enum.GetValues(typeof(Glyph)))

FSharpHighlightSpanKindTests.cs (1)

20foreach (var number in Enum.GetValues(typeof(FSharpHighlightSpanKind)))

FSharpInlineRenameReplacementKindTests.cs (1)

20foreach (var number in Enum.GetValues(typeof(FSharpInlineRenameReplacementKind)))

FSharpNavigateToMatchKindTests.cs (1)

20foreach (var number in Enum.GetValues(typeof(FSharpNavigateToMatchKind)))

FSharpSignatureHelpTriggerReasonTests.cs (1)

20foreach (var number in Enum.GetValues(typeof(SignatureHelpTriggerReason)))

EnumTests.cs (4)

28var internalValues = Enum.GetValues(internalType).Cast<int>().ToArray(); 29var internalNames = Enum.GetNames(internalType); 30var externalValues = Enum.GetValues(externalType).Cast<int>().ToArray(); 31var externalNames = Enum.GetNames(externalType);

CodeFixes\Configuration\ConfigureCodeStyle\ConfigureCodeStyleOptionCodeFixProvider.cs (1)

122foreach (var enumValue in Enum.GetValues(t))

CodeRefactorings\CodeRefactoringService.cs (1)

55var kind = (TextDocumentKind)Enum.Parse(typeof(TextDocumentKind), documentKind, ignoreCase: true);

EditAndContinue\EditAndContinueDiagnosticDescriptors.cs (1)

207foreach (var value in Enum.GetValues<ProjectSettingKind>())

EmbeddedLanguages\AbstractLanguageDetector.cs (2)

20where TOptions : struct, Enum 177where TOptions : struct, Enum

EmbeddedLanguages\EmbeddedLanguageCommentOptions.cs (1)

21internal static class EmbeddedLanguageCommentOptions<TOptions> where TOptions : struct, Enum

ExtractMethod\AbstractSyntaxTriviaService.cs (1)

30Debug.Assert(Enum.GetNames(typeof(TriviaLocation)).Length == TriviaLocationsCount);

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (3)

423var enumIsDefinedMembers = enumType.GetMembers(nameof(Enum.IsDefined)); 643var enumIsDefinedGenericMethod = enumType.GetMembers(nameof(Enum.IsDefined)).FirstOrDefault(m => m is IMethodSymbol { IsStatic: true, Arity: 1, Parameters.Length: 1 }); 665nameof(Enum.IsDefined)),

InvertIf\AbstractInvertIfCodeRefactoringProvider.cs (1)

26where TSyntaxKind : struct, Enum

NavigateTo\AbstractNavigateToSearchService.InProcess.cs (2)

253Debug.Assert(Enum.GetUnderlyingType(typeof(DeclaredSymbolInfoKind)) == typeof(byte)); 255var lookupTable = new bool[Enum.GetValues<DeclaredSymbolInfoKind>().Length];

QuickInfo\Presentation\QuickInfoContentBuilder.cs (1)

22var glyphs = Enum.GetValues<Glyph>();

src\Analyzers\Core\Analyzers\ForEachCast\AbstractForEachCastDiagnosticAnalyzer.cs (1)

22where TSyntaxKind : struct, Enum

src\Analyzers\Core\Analyzers\MakeFieldReadonly\AbstractMakeFieldReadonlyDiagnosticAnalyzer.cs (1)

24where TSyntaxKind : struct, Enum

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\SuppressMessageAttributeState.cs (1)

29foreach (var targetScope in Enum.GetValues<TargetScope>())

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (1)

37where TSyntaxKind : struct, Enum

EditAndContinue\EditAndContinueCapabilitiesTests.cs (2)

59foreach (var name in Enum.GetNames(typeof(EditAndContinueCapabilities))) 65var flag = (EditAndContinueCapabilities)Enum.Parse(typeof(EditAndContinueCapabilities), name);

EditAndContinue\RudeEditDiagnosticTests.cs (1)

74var allKinds = Enum.GetValues<RudeEditKind>();

FindUsages\DefinitionItemFactoryTests.cs (1)

35private static string InspectFlags<TEnum>(TEnum e) where TEnum : Enum

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

LanguageServer\Handler\Logging\UpdateLogLevelHandler.cs (1)

27var level = Enum.Parse<LogLevel>(request.LogLevelValue);

Logging\RoslynLogger.cs (1)

230=> Enum.GetName(typeof(FunctionId), id)!.Replace('_', separator).ToLowerInvariant();

Extensions\ProtocolConversions.cs (2)

546if (Enum.TryParse<LSP.SymbolKind>(kind, out var symbolKind)) 651if (Enum.TryParse<LSP.SymbolKind>(glyphString, out var symbolKind))

Configuration\DidChangeConfigurationNotificationHandlerTest.cs (2)

301null => Enum.GetValues(type).GetValue(0), 312foreach (var value in Enum.GetValues(type))

src\Compilers\Core\Portable\InternalUtilities\EnumUtilties.cs (3)

16return (T[])Enum.GetValues(typeof(T)); 20internal static bool ContainsAllValues<T>(int mask) where T : struct, Enum, IConvertible 33internal static bool ContainsValue<T>(T value) where T : struct, Enum

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

181&& Enum.GetUnderlyingType(typeof(TValue)).GetTypeInfo().IsAssignableFrom(Enum.GetUnderlyingType(resultType).GetTypeInfo()))

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (3)

29ImmutableHashSet.CreateRange(Enum.GetValues<OutputKind>()); 146tryParseValue: static (value, out result) => Enum.TryParse(value, ignoreCase: true, result: out result), 166if (Enum.TryParse(kindStr, ignoreCase: true, result: out TEnum kind))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\CodeStyle\CodeStyleOption2`1.cs (1)

188var severity = (DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), severityAttribute.Value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (1)

480capitalizationScheme: (Capitalization)Enum.Parse(typeof(Capitalization), namingStyleElement.Attribute(nameof(CapitalizationScheme)).Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SerializableNamingRule.cs (1)

38EnforcementLevel = ((DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), namingRuleElement.Attribute(nameof(EnforcementLevel))!.Value)).ToReportDiagnostic(),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (5)

310=> (Accessibility)Enum.Parse(typeof(Accessibility), accessibilityElement.Value); 421var symbolKind = (SymbolKind)Enum.Parse(typeof(SymbolKind), symbolKindElement.Value); 433=> new((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value)); 436=> new((MethodKind)Enum.Parse(typeof(MethodKind), methodKindElement.Value)); 536=> new((ModifierKindEnum)Enum.Parse(typeof(ModifierKindEnum), modifierElement.Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (9)

104public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>() where T : struct, Enum 112public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map) where T : struct, Enum 119public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map, ImmutableDictionary<string, T> alternative) where T : struct, Enum 127public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(IEnumerable<(string name, T value)> entries, IEnumerable<(string name, T value)> alternativeEntries) where T : struct, Enum 136public static EditorConfigValueSerializer<T?> CreateSerializerForNullableEnum<T>() where T : struct, Enum 158private static bool TryParseEnum<T>(string str, out T result) where T : struct, Enum 173return Enum.TryParse(str, ignoreCase: true, out result); 209where TFromEnum : struct, Enum 210where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (1)

27=> (SpecialType)Enum.Parse(typeof(SpecialType), arg);

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

144where TFromEnum : struct, Enum 145where TToEnum : struct, Enum

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

17where TFromEnum : struct, Enum 18where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.AbstractTypeInferrer.cs (1)

119symbol.Name == nameof(Enum.HasFlag) &&

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

src\Compilers\Core\Portable\InternalUtilities\EnumUtilties.cs (3)

16return (T[])Enum.GetValues(typeof(T)); 20internal static bool ContainsAllValues<T>(int mask) where T : struct, Enum, IConvertible 33internal static bool ContainsValue<T>(T value) where T : struct, Enum

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

181&& Enum.GetUnderlyingType(typeof(TValue)).GetTypeInfo().IsAssignableFrom(Enum.GetUnderlyingType(resultType).GetTypeInfo()))

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (3)

29ImmutableHashSet.CreateRange(Enum.GetValues<OutputKind>()); 146tryParseValue: static (value, out result) => Enum.TryParse(value, ignoreCase: true, result: out result), 166if (Enum.TryParse(kindStr, ignoreCase: true, result: out TEnum kind))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\CodeStyle\CodeStyleOption2`1.cs (1)

188var severity = (DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), severityAttribute.Value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (1)

480capitalizationScheme: (Capitalization)Enum.Parse(typeof(Capitalization), namingStyleElement.Attribute(nameof(CapitalizationScheme)).Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SerializableNamingRule.cs (1)

38EnforcementLevel = ((DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), namingRuleElement.Attribute(nameof(EnforcementLevel))!.Value)).ToReportDiagnostic(),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (5)

310=> (Accessibility)Enum.Parse(typeof(Accessibility), accessibilityElement.Value); 421var symbolKind = (SymbolKind)Enum.Parse(typeof(SymbolKind), symbolKindElement.Value); 433=> new((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value)); 436=> new((MethodKind)Enum.Parse(typeof(MethodKind), methodKindElement.Value)); 536=> new((ModifierKindEnum)Enum.Parse(typeof(ModifierKindEnum), modifierElement.Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (9)

104public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>() where T : struct, Enum 112public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map) where T : struct, Enum 119public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map, ImmutableDictionary<string, T> alternative) where T : struct, Enum 127public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(IEnumerable<(string name, T value)> entries, IEnumerable<(string name, T value)> alternativeEntries) where T : struct, Enum 136public static EditorConfigValueSerializer<T?> CreateSerializerForNullableEnum<T>() where T : struct, Enum 158private static bool TryParseEnum<T>(string str, out T result) where T : struct, Enum 173return Enum.TryParse(str, ignoreCase: true, out result); 209where TFromEnum : struct, Enum 210where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (1)

27=> (SpecialType)Enum.Parse(typeof(SpecialType), arg);

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

144where TFromEnum : struct, Enum 145where TToEnum : struct, Enum

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

17where TFromEnum : struct, Enum 18where TToEnum : struct, Enum

CompilationFactory.cs (1)

211: (Platform)Enum.Parse(typeof(Platform), platform);

CSharpCompilationFactory.cs (1)

84: (NullableContextOptions)Enum.Parse(typeof(NullableContextOptions), nullable);

MetadataCompilationOptions.cs (1)

64public static T? ToEnum<T>(string value) where T : struct => Enum.TryParse<T>(value, out var enumValue) ? enumValue : null;

CSharpDeterministicKeyBuilderTests.cs (1)

276foreach (BinderFlags binderFlags in Enum.GetValues(typeof(BinderFlags)))

OptionRoundTripTests.cs (1)

33public static readonly object[][] Platforms = ((Platform[])Enum.GetValues(typeof(Platform))).Select(p => new[] { (object)p }).ToArray();

src\VisualStudio\Core\Def\Telemetry\Shared\TelemetryLogger.cs (1)

94=> Enum.GetName(typeof(FunctionId), id)!.Replace('_', separator).ToLowerInvariant();

src\Compilers\Core\Portable\InternalUtilities\EnumUtilties.cs (3)

16return (T[])Enum.GetValues(typeof(T)); 20internal static bool ContainsAllValues<T>(int mask) where T : struct, Enum, IConvertible 33internal static bool ContainsValue<T>(T value) where T : struct, Enum

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

181&& Enum.GetUnderlyingType(typeof(TValue)).GetTypeInfo().IsAssignableFrom(Enum.GetUnderlyingType(resultType).GetTypeInfo()))

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (3)

29ImmutableHashSet.CreateRange(Enum.GetValues<OutputKind>()); 146tryParseValue: static (value, out result) => Enum.TryParse(value, ignoreCase: true, result: out result), 166if (Enum.TryParse(kindStr, ignoreCase: true, result: out TEnum kind))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\CodeStyle\CodeStyleOption2`1.cs (1)

188var severity = (DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), severityAttribute.Value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (1)

480capitalizationScheme: (Capitalization)Enum.Parse(typeof(Capitalization), namingStyleElement.Attribute(nameof(CapitalizationScheme)).Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SerializableNamingRule.cs (1)

38EnforcementLevel = ((DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), namingRuleElement.Attribute(nameof(EnforcementLevel))!.Value)).ToReportDiagnostic(),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (5)

310=> (Accessibility)Enum.Parse(typeof(Accessibility), accessibilityElement.Value); 421var symbolKind = (SymbolKind)Enum.Parse(typeof(SymbolKind), symbolKindElement.Value); 433=> new((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value)); 436=> new((MethodKind)Enum.Parse(typeof(MethodKind), methodKindElement.Value)); 536=> new((ModifierKindEnum)Enum.Parse(typeof(ModifierKindEnum), modifierElement.Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (9)

104public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>() where T : struct, Enum 112public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map) where T : struct, Enum 119public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map, ImmutableDictionary<string, T> alternative) where T : struct, Enum 127public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(IEnumerable<(string name, T value)> entries, IEnumerable<(string name, T value)> alternativeEntries) where T : struct, Enum 136public static EditorConfigValueSerializer<T?> CreateSerializerForNullableEnum<T>() where T : struct, Enum 158private static bool TryParseEnum<T>(string str, out T result) where T : struct, Enum 173return Enum.TryParse(str, ignoreCase: true, out result); 209where TFromEnum : struct, Enum 210where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (1)

27=> (SpecialType)Enum.Parse(typeof(SpecialType), arg);

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

144where TFromEnum : struct, Enum 145where TToEnum : struct, Enum

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

17where TFromEnum : struct, Enum 18where TToEnum : struct, Enum

Diagnostics\DiagnosticDescription.cs (1)

392sb.Append(Enum.GetName(_errorCodeType, _code));

Diagnostics\TestDiagnosticAnalyzer.cs (1)

30return ImmutableArray.CreateRange(Enum.GetValues(typeof(T)).Cast<T>());

src\Dependencies\Contracts\EnumExtensions.cs (4)

12public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 13=> Enum.GetValues<TEnum>(); 15public static string[] GetNames<TEnum>() where TEnum : struct, Enum 16=> Enum.GetNames<TEnum>();

Collections\List\ICollection.NonGeneric.Tests.cs (1)

238Array enumArr = Enum.GetValues(typeof(EnumerableType));

Collections\List\TestBase.Generic.cs (1)

51((IEnumerable<EnumerableType>)Enum.GetValues(typeof(EnumerableType))).SelectMany(GetEnumerableTestData);

CommonSyntaxTests.cs (2)

22foreach (CS.SyntaxKind kind in Enum.GetValues(typeof(CS.SyntaxKind))) 32foreach (VB.SyntaxKind kind in Enum.GetValues(typeof(VB.SyntaxKind)))

MetadataReferences\MetadataHelpersTests.cs (1)

85foreach (ArrayKind arrayKind in Enum.GetValues(typeof(ArrayKind)))

CommandLine\VisualBasicCompiler.vb (1)

240For Each v As LanguageVersion In System.Enum.GetValues(GetType(LanguageVersion))

CodeCleanup\AbstractCodeCleanerService.cs (1)

670var types = annotation.Data.Split(s_separators).Select(s => (SpanMarkerType)Enum.Parse(typeof(SpanMarkerType), s)).ToArray();

CodeFixes\ExportCodeFixProviderAttribute.cs (1)

22private static readonly string[] s_documentKindNames = Enum.GetNames(typeof(TextDocumentKind));

CodeFixesAndRefactorings\EnumArrayConverter.cs (2)

12public static ImmutableArray<TEnum> FromStringArray<TEnum>(string[] strings) where TEnum : struct, Enum 18if (!Enum.TryParse(s, out TEnum enumValue))

CodeRefactorings\ExportCodeRefactoringProviderAttribute.cs (1)

20private static readonly string[] s_documentKindNames = Enum.GetNames(typeof(TextDocumentKind));

Editing\DeclarationModifiers.cs (1)

234if (Enum.TryParse(value, out Modifiers mods))

Log\FunctionIdExtensions.cs (1)

14() => Enum.GetValues<FunctionId>().ToImmutableDictionary(f => f, f => f.ToString()));

Options\OptionExtensions.cs (2)

20where TFromEnum : struct, Enum 21where TToEnum : struct, Enum

src\Compilers\Core\Portable\InternalUtilities\EnumUtilties.cs (3)

16return (T[])Enum.GetValues(typeof(T)); 20internal static bool ContainsAllValues<T>(int mask) where T : struct, Enum, IConvertible 33internal static bool ContainsValue<T>(T value) where T : struct, Enum

src\Dependencies\Contracts\EnumExtensions.cs (4)

12public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 13=> Enum.GetValues<TEnum>(); 15public static string[] GetNames<TEnum>() where TEnum : struct, Enum 16=> Enum.GetNames<TEnum>();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\CodeStyle\CodeStyleOption2`1.cs (1)

188var severity = (DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), severityAttribute.Value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (1)

480capitalizationScheme: (Capitalization)Enum.Parse(typeof(Capitalization), namingStyleElement.Attribute(nameof(CapitalizationScheme)).Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SerializableNamingRule.cs (1)

38EnforcementLevel = ((DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), namingRuleElement.Attribute(nameof(EnforcementLevel))!.Value)).ToReportDiagnostic(),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (5)

310=> (Accessibility)Enum.Parse(typeof(Accessibility), accessibilityElement.Value); 421var symbolKind = (SymbolKind)Enum.Parse(typeof(SymbolKind), symbolKindElement.Value); 433=> new((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value)); 436=> new((MethodKind)Enum.Parse(typeof(MethodKind), methodKindElement.Value)); 536=> new((ModifierKindEnum)Enum.Parse(typeof(ModifierKindEnum), modifierElement.Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (9)

104public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>() where T : struct, Enum 112public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map) where T : struct, Enum 119public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map, ImmutableDictionary<string, T> alternative) where T : struct, Enum 127public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(IEnumerable<(string name, T value)> entries, IEnumerable<(string name, T value)> alternativeEntries) where T : struct, Enum 136public static EditorConfigValueSerializer<T?> CreateSerializerForNullableEnum<T>() where T : struct, Enum 158private static bool TryParseEnum<T>(string str, out T result) where T : struct, Enum 173return Enum.TryParse(str, ignoreCase: true, out result); 209where TFromEnum : struct, Enum 210where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (1)

27=> (SpecialType)Enum.Parse(typeof(SpecialType), arg);

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

144where TFromEnum : struct, Enum 145where TToEnum : struct, Enum

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

17where TFromEnum : struct, Enum 18where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.AbstractTypeInferrer.cs (1)

119symbol.Name == nameof(Enum.HasFlag) &&

MSBuild\ProjectFile\Conversions.cs (1)

62return Enum.TryParse<TEnum>(value, ignoreCase, out var result)

src\Compilers\Core\Portable\InternalUtilities\EnumUtilties.cs (3)

16return (T[])Enum.GetValues(typeof(T)); 20internal static bool ContainsAllValues<T>(int mask) where T : struct, Enum, IConvertible 33internal static bool ContainsValue<T>(T value) where T : struct, Enum

src\Compilers\Core\Portable\InternalUtilities\JsonWriter.cs (3)

109public void Write<T>(string key, T value) where T : struct, Enum 195public void Write<T>(T value) where T : struct, Enum 200public void Write<T>(T? value) where T : struct, Enum

src\Dependencies\Contracts\EnumExtensions.cs (4)

12public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 13=> Enum.GetValues<TEnum>(); 15public static string[] GetNames<TEnum>() where TEnum : struct, Enum 16=> Enum.GetNames<TEnum>();

VisualStudioMSBuildWorkspaceTests.cs (2)

2231Enum.GetName(typeof(WorkspaceChangeKind), expectedEventKind), 2267Enum.GetName(typeof(WorkspaceChangeKind), expectedEventKind),

Options\OptionsTestHelpers.cs (3)

126_ when Nullable.GetUnderlyingType(type) is { IsEnum: true } underlying => value is null ? Enum.ToObject(underlying, 1) : null, 148var zero = Enum.ToObject(type, 0); 149return defaultValue.Equals(zero) ? Enum.ToObject(type, 1) : zero;

Workspaces\TestWorkspace_XmlConsumption.cs (5)

337return (DocumentationMode)Enum.Parse(typeof(DocumentationMode), documentationModeAttribute.Value); 435outputKind = (OutputKind)Enum.Parse(typeof(OutputKind), outputKindAttribute.Value); 453reportDiagnostic = (ReportDiagnostic)Enum.Parse(typeof(ReportDiagnostic), (string)reportDiagnosticAttribute); 488nullable = (NullableContextOptions)Enum.Parse(typeof(NullableContextOptions), nullableAttribute.Value); 627: (SourceCodeKind)Enum.Parse(typeof(SourceCodeKind), attr.Value);

FindAllDeclarationsTests.TestSolutionsAndProject.cs (2)

38Enum.GetName(typeof(SolutionKind), workspaceKind))); 53Enum.GetName(typeof(SolutionKind), workspaceKind)));

FunctionIdTests.cs (2)

18foreach (var name in Enum.GetNames(typeof(FunctionId))) 20var value = (FunctionId)Enum.Parse(typeof(FunctionId), name);

Host\LanguageServices\TestCSharpCompilationFactoryServiceWithIncrementalGeneratorTracking.cs (1)

50!Enum.TryParse<OutputKind>(outputKindString, out var outputKind))

ObjectSerializationTests.cs (1)

96? (T)Enum.ToObject(typeof(T), r.ReadInt64())

src\Dependencies\Contracts\EnumExtensions.cs (4)

12public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 13=> Enum.GetValues<TEnum>(); 15public static string[] GetNames<TEnum>() where TEnum : struct, Enum 16=> Enum.GetNames<TEnum>();

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

Microsoft\CSharp\RuntimeBinder\Semantics\Operators.cs (3)

1073Debug.Assert(Enum.IsDefined(bt1)); 1074Debug.Assert(Enum.IsDefined(bt2)); 1582Debug.Assert(Enum.IsDefined(bt));

Microsoft\CSharp\RuntimeBinder\Semantics\Tree\Constant.cs (1)

78return Type.IsEnumType ? Enum.ToObject(Type.AssociatedSystemType, objval) : objval;

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

152new PredefinedTypeInfo(PredefinedType.PT_ENUM, typeof(Enum), "System.Enum"),

Microsoft\CSharp\RuntimeBinder\SymbolTable.cs (1)

880agg.SetUnderlyingType((AggregateType)GetCTypeFromType(Enum.GetUnderlyingType(type)));

src\SetCorFlags.cs (1)

63if (Enum.TryParse<CorFlags>(value, out var result))

PipelinesLogger.cs (1)

38Verbosity = !string.IsNullOrEmpty(verbosityString) && Enum.TryParse(verbosityString, out LoggerVerbosity verbosity)

ArtifactModel.cs (1)

60else if (Enum.TryParse(val, out ArtifactVisibility visibility))

BuildIdentity.cs (1)

224return (PublishingInfraVersion)Enum.Parse(typeof(PublishingInfraVersion), value, true);

src\Common\Internal\EnumExtensions.cs (2)

14public static string GetDescription(this Enum value) 17string name = Enum.GetName(type, value);

src\PublishArtifactsInManifest.cs (1)

175set { Enum.TryParse<PublishingConstants.BuildQuality>(value, true, out _buildQuality); }

src\PublishArtifactsInManifestBase.cs (2)

1175if (!Enum.TryParse(category, ignoreCase: true, out TargetFeedContentType categoryKey)) 1203if (!Enum.TryParse(category, ignoreCase: true, out TargetFeedContentType categoryKey))

src\PushToBuildStorage.cs (2)

191if (!Enum.IsDefined(typeof(PublishingInfraVersion), PublishingVersion)) 504if (Enum.TryParse(item.ItemSpec, true, out ArtifactVisibility parsedVisibility))

GeneralTests.cs (1)

31foreach (TargetFeedContentType type in Enum.GetValues(typeof(TargetFeedContentType)))

PublishToSymbolServerTest.cs (1)

81IEnumerable<SymbolPublishVisibility> visibilities = Enum.GetValues<SymbolPublishVisibility>().Where(x => x <= maxVisibility);

src\RpmBuilder.cs (2)

224entries.Add(new((RpmHeaderTag)Enum.Parse(typeof(RpmHeaderTag), script.Key), RpmHeaderEntryType.String, script.Value)); 225entries.Add(new((RpmHeaderTag)Enum.Parse(typeof(RpmHeaderTag), $"{script.Key}prog"), RpmHeaderEntryType.String, "/bin/sh"));

src\RpmHeader.cs (2)

18where TEntryTag : struct, Enum 33: this((TEntryTag)Enum.ToObject(typeof(TEntryTag), entryTag), type, value)

Extensions.cs (1)

70Enum.TryParse(packageDirectoryName, true, out result);

ValidationTask.cs (1)

115if (!Enum.TryParse<Suppression>(keyString, out key))

GenAPITask.cs (3)

72set => _writerType = string.IsNullOrWhiteSpace(value) ? default : (WriterType) Enum.Parse(typeof(WriterType), value, true); 81set => _syntaxWriterType = string.IsNullOrWhiteSpace(value) ? default : (SyntaxWriterType)Enum.Parse(typeof(SyntaxWriterType), value, true); 90set => _docIdKinds = string.IsNullOrWhiteSpace(value) ? Cci.Writers.DocIdKinds.All : (DocIdKinds)Enum.Parse(typeof(DocIdKinds), value, true);

generated-code\HelixApi.cs (1)

226if (value is Enum)

SymbolPromotionHelper.cs (1)

84if (!Enum.IsDefined(visibility))

src\SignCheck.cs (1)

146if (Enum.TryParse<FileStatus>(value, out result))

src\SignCheckTask.cs (1)

177if(Enum.TryParse<LogVerbosity>(Verbosity, out LogVerbosity verbosity))

src\SignToolTask.cs (2)

604if (!string.IsNullOrEmpty(executableTypeMetadata) && !Enum.TryParse<ExecutableType>(executableTypeMetadata, true, out executableType)) 648return Enum.TryParse<ExecutableType>(executableType, out var type);

src\ZipData.cs (1)

732string kind = Enum.GetName(scriptTag);

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

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

757foreach (string name in Enum.GetNames(typeInfo.Type))

src\Shared\JsonSchemaExporter\JsonSchemaExporter.ReflectionHelpers.cs (2)

321return Enum.ToObject(parameterType, defaultValue); 326return Enum.ToObject(underlyingType, defaultValue);

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

Utilities\AIJsonUtilities.Schema.Create.cs (2)

737return Enum.ToObject(parameterType, defaultValue); 742return Enum.ToObject(underlyingType, defaultValue);

Image\ImageGenerationOptionsTests.cs (2)

122Assert.True(Enum.IsDefined(typeof(ImageGenerationResponseFormat), responseFormat)); 128foreach (ImageGenerationResponseFormat responseFormat in Enum.GetValues(typeof(ImageGenerationResponseFormat)))

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

223where T : struct, Enum 228if (!Enum.IsDefined(typeof(T), argument))

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

ResultsTests.cs (1)

140if (!Enum.TryParse(e.Value, out MeasurementSystem measurementSystem))

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

JsonSerialization\CamelCaseEnumConverter.cs (1)

11where TEnum : struct, System.Enum;

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

src\Libraries\Microsoft.Extensions.AI.Evaluation.Reporting\CSharp\JsonSerialization\CamelCaseEnumConverter.cs (1)

11where TEnum : struct, System.Enum;

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

ContentSafetyEvaluator.cs (1)

102Enum.Parse<ContentSafetyServicePayloadFormat>(contentSafetyServicePayloadFormat);

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

ChatCompletion\ChatClientStructuredOutputExtensionsTests.cs (1)

132foreach (Species v in Enum.GetValues(typeof(Species)))

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

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

223where T : struct, Enum 228if (!Enum.IsDefined(typeof(T), argument))

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

223where T : struct, Enum 228if (!Enum.IsDefined(typeof(T), argument))

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

223where T : struct, Enum 228if (!Enum.IsDefined(typeof(T), argument))

src\LegacySupport\StringSyntaxAttribute\StringSyntaxAttribute.cs (1)

48/// <summary>The syntax identifier for strings containing <see cref="Enum"/> format specifiers.</summary>

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

223where T : struct, Enum 228if (!Enum.IsDefined(typeof(T), argument))

src\LegacySupport\StringSyntaxAttribute\StringSyntaxAttribute.cs (1)

48/// <summary>The syntax identifier for strings containing <see cref="Enum"/> format specifiers.</summary>

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

223where T : struct, Enum 228if (!Enum.IsDefined(typeof(T), argument))

ConfigurationBinder.cs (1)

768object key = keyTypeIsEnum ? Enum.Parse(keyType, child.Key, true) :

src\libraries\Common\src\Extensions\ParameterDefaultValue\ParameterDefaultValue.cs (1)

55defaultValue = Enum.ToObject(underlyingType, defaultValue);

src\libraries\Common\src\Extensions\ParameterDefaultValue\ParameterDefaultValue.cs (1)

55defaultValue = Enum.ToObject(underlyingType, defaultValue);

src\libraries\Common\src\Extensions\ParameterDefaultValue\ParameterDefaultValue.cs (1)

55defaultValue = Enum.ToObject(underlyingType, defaultValue);

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

HttpExceptionSummaryProvider.cs (2)

42foreach (var v in Enum.GetValues(typeof(SocketError))) 57foreach (var v in Enum.GetValues(typeof(WebExceptionStatus)))

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

223where T : struct, Enum 228if (!Enum.IsDefined(typeof(T), argument))

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

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

223where T : struct, Enum 228if (!Enum.IsDefined(typeof(T), argument))

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

DependencyInjection\SocketsHttpHandlerBuilderExtensions.cs (2)

55/// Only simple (of type `bool`, `int`, <see cref="Enum"/> or <see cref="TimeSpan"/>) properties of <see cref="SocketsHttpHandler"/> will be parsed. 218=> Enum.TryParse<TEnum>(enumString, ignoreCase: true, out var result) ? result : null;

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

223where T : struct, Enum 228if (!Enum.IsDefined(typeof(T), argument))

LoggerFilterConfigureOptions.cs (1)

79else if (Enum.TryParse(value, true, out level))

ConfigurationConsoleLoggerSettings.cs (1)

92else if (Enum.TryParse<LogLevel>(value, true, out level))

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

223where T : struct, Enum 228if (!Enum.IsDefined(typeof(T), argument))

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

ThrowHelper.cs (2)

61Debug.Assert(Enum.IsDefined(typeof(ExceptionResource), resource), 79Debug.Assert(Enum.IsDefined(typeof(ExceptionArgument), argument),

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

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

223where T : struct, Enum 228if (!Enum.IsDefined(typeof(T), argument))

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

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

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

223where T : struct, Enum 228if (!Enum.IsDefined(typeof(T), argument))

Analyzers\ConvertComImportToGeneratedComInterfaceAnalyzer.cs (1)

177return !Enum.IsDefined(typeof(UnmanagedType), unmanagedType)

JSMarshalAsAttributeInfoParser.cs (3)

33Enum.TryParse(name, out jsType); 39Enum.TryParse(argName, out jsTypeArg); 47Enum.TryParse(name, out jsType);

Analyzers\ConvertToLibraryImportAnalyzer.cs (1)

206return !Enum.IsDefined(typeof(UnmanagedType), unmanagedType)

Analyzers\ConvertToLibraryImportFixer.cs (1)

80CharSet? charSet = options.TryGetValue(CharSetOption, out Option charSetOption) && charSetOption is Option.String(string charSetString) && Enum.TryParse<CharSet>(charSetString, out CharSet result) ? result : null;

Analyzers\CustomMarshallerAttributeAnalyzer.cs (1)

690|| !Enum.IsDefined(typeof(MarshalMode), (MarshalMode)marshalMode))

LibraryImportGenerator.cs (1)

532static ExpressionSyntax CreateEnumExpressionSyntax<T>(T value) where T : Enum

MarshalAsParser.cs (1)

158if (!Enum.IsDefined(typeof(UnmanagedType), unmanagedType)

Converters\FlexEnumsConverters.cs (6)

24 if (Enum.TryParse(strValue, true, out FlexJustify justify)) 63 if (Enum.TryParse(strValue, true, out FlexDirection aligncontent)) 98 if (Enum.TryParse(strValue, true, out FlexAlignContent aligncontent)) 137 if (Enum.TryParse(strValue, true, out FlexAlignItems alignitems)) 172 if (Enum.TryParse(strValue, true, out FlexAlignSelf alignself)) 207 if (Enum.TryParse(strValue, true, out FlexWrap wrap))

Button\Button.cs (1)

604 position = (ButtonContentLayout.ImagePosition)Enum.Parse(typeof(ButtonContentLayout.ImagePosition), parts[positionIndex], true);

CompareStateTrigger.cs (3)

74 if (value2 is Enum) 86 return Enum.IsDefined(enumType, value) ? Enum.ToObject(enumType, value) : null;

DecorableTextElement.cs (1)

38 if (Enum.TryParse(item.Trim(), true, out TextDecorations textDecorations))

FlowDirectionConverter.cs (1)

22 if (Enum.TryParse(strValue, out FlowDirection direction))

FontAttributes.cs (1)

56 if (Enum.TryParse(part, true, out FontAttributes attr))

FontSizeConverter.cs (2)

52 else if (Enum.TryParse(value, ignoreCase, out NamedSize ns)) 96 if (Enum.TryParse(strValue, out NamedSize namedSize))

ListView\ListView.cs (2)

389 if (!Enum.IsDefined(typeof(ScrollToPosition), position)) 404 if (!Enum.IsDefined(typeof(ScrollToPosition), position))

ScrollView\ScrollView.cs (1)

264 if (!Enum.IsDefined(typeof(ScrollToPosition), position))

TextAlignment.cs (1)

38 if (Enum.TryParse(strValue, out TextAlignment direction))

Xaml\TypeConversionExtensions.cs (1)

173 return Enum.Parse(toType, str, ignoreCase);

CompiledConverters\EnumTypeConverter.cs (1)

16 if (Enum.TryParse(value, out TEnum enumValue))

CompiledConverters\FontSizeTypeConverter.cs (1)

26 if (Enum.TryParse(value, out NamedSize namedSize))

SetPropertiesVisitor.cs (1)

506 || !Enum.TryParse((modeNode as ValueNode)?.Value as string, true, out BindingMode declaredmode))

ButtonContentDesignTypeConverter.cs (2)

34 if (parts.Length == 2 && !Enum.TryParse(parts[1], true, out ImagePosition _)) 40 if (!Enum.TryParse(parts[0], true, out ImagePosition _))

Text\TextAttributesExtensions.cs (1)

135 if (Enum.TryParse(value, out T enumValue))

Text\XmlAttributedTextReader.cs (1)

126 if (Enum.TryParse(attributeName, out TextAttribute key))

API\BinaryClassificationExperiment.cs (1)

50Trainers = Enum.GetValues(typeof(BinaryClassificationTrainer)).OfType<BinaryClassificationTrainer>().ToList();

API\MulticlassClassificationExperiment.cs (1)

45Trainers = Enum.GetValues(typeof(MulticlassClassificationTrainer)).OfType<MulticlassClassificationTrainer>().ToList();

API\RankingExperiment.cs (1)

44Trainers = Enum.GetValues(typeof(RankingTrainer)).OfType<RankingTrainer>().ToList();

API\RecommendationExperiment.cs (1)

35Trainers = Enum.GetValues(typeof(RecommendationTrainer)).OfType<RecommendationTrainer>().ToList();

API\RegressionExperiment.cs (1)

45Trainers = Enum.GetValues(typeof(RegressionTrainer)).OfType<RegressionTrainer>().ToList();

ColumnInference\ColumnGroupingInference.cs (1)

124return Enum.GetName(typeof(ColumnPurpose), purpose);

Experiment\SuggestedPipeline.cs (2)

86var trainerName = (TrainerName)Enum.Parse(typeof(TrainerName), pipelineNode.Name); 95var estimatorName = (EstimatorName)Enum.Parse(typeof(EstimatorName), pipelineNode.Name);

TrainerExtensions\TrainerExtensionUtil.cs (1)

283.ToDictionary(v => Enum.GetName(fi.FieldType, v), v => v);

Utils\SweepableParamAttributes.cs (1)

93case Enum _:

EstimatorExtensionTests.cs (1)

32var estimatorNames = Enum.GetValues(typeof(EstimatorName)).Cast<EstimatorName>();

TrainerExtensionsTests.cs (6)

27var trainerNames = Enum.GetValues(typeof(TrainerName)).Cast<TrainerName>() 357var publicNames = Enum.GetValues(typeof(BinaryClassificationTrainer)).Cast<BinaryClassificationTrainer>(); 365var publicNames = Enum.GetValues(typeof(MulticlassClassificationTrainer)).Cast<MulticlassClassificationTrainer>(); 373var publicNames = Enum.GetValues(typeof(RegressionTrainer)).Cast<RegressionTrainer>(); 381var publicNames = Enum.GetValues(typeof(RecommendationTrainer)).Cast<RecommendationTrainer>(); 389var publicNames = Enum.GetValues(typeof(RankingTrainer)).Cast<RankingTrainer>();

CodeGenerator\CSharp\TrainerGeneratorFactory.cs (1)

22if (Enum.TryParse(node.Name, out TrainerName trainer))

CodeGenerator\CSharp\TransformGeneratorFactory.cs (2)

31if (Enum.TryParse(node.Name, out EstimatorName trainer)) 84if (Enum.TryParse(node.Name, out SpecialTransformer transformer))

CommandLine\CmdParser.cs (1)

1893value = Enum.Parse(type, data, true);

EntryPoints\ModuleArgs.cs (1)

373case Enum _:

Utilities\Utils.cs (2)

1246public static string GetDescription(this Enum value) 1249string name = Enum.GetName(type, value);

UnitTests\TestVBuffer.cs (1)

1099Contracts.Assert(cases == Enum.GetValues(typeof(GenLogic)).Length);

Commands\TrainCommand.cs (1)

449ch.CheckUserArg(Enum.IsDefined(typeof(NormalizeOption), autoNorm), nameof(TrainCommand.Arguments.NormalizeFeatures),

Commands\TypeInfoCommand.cs (1)

87var kinds = Enum.GetValues(typeof(InternalDataKind)).Cast<InternalDataKind>().Distinct().OrderBy(k => k).ToArray();

DataLoadSave\Binary\BinaryLoader.cs (5)

344bool knowCompression = Enum.IsDefined(typeof(CompressionKind), compression); 503ectx.Assert(Enum.IsDefined(typeof(CompressionKind), compression)); 530Contracts.Assert((codec == null) || !Enum.IsDefined(typeof(CompressionKind), compression)); 1110bool knowCompression = Enum.IsDefined(typeof(CompressionKind), compression); 1779Ectx.Assert(Enum.IsDefined(typeof(CompressionKind), entry.Compression));

DataLoadSave\Database\DatabaseLoader.cs (2)

499ch.CheckUserArg(Enum.IsDefined(typeof(DbType), col.Type), nameof(Column.Type), "Bad item type"); 570Contracts.CheckDecode(Enum.IsDefined(typeof(InternalDataKind), kind));

DataLoadSave\Text\TextLoader.cs (2)

777ch.CheckUserArg(Enum.IsDefined(typeof(InternalDataKind), kind), nameof(Column.Type), "Bad item type"); 935Contracts.CheckDecode(Enum.IsDefined(typeof(InternalDataKind), kind));

EntryPoints\InputBuilder.cs (2)

446if (!Enum.IsDefined(type, value.Value<string>())) 448return Enum.Parse(type, value.Value<string>());

Model\Pfa\SavePfaCommand.cs (1)

82Host.CheckUserArg(Enum.IsDefined(typeof(Formatting), args.Formatting), nameof(args.Formatting), "Undefined value");

Transforms\ColumnSelecting.cs (2)

345Contracts.Assert(Enum.IsDefined(typeof(HiddenColumnOption), hiddenOption)); 361Contracts.Assert(Enum.IsDefined(typeof(HiddenColumnOption), colHiddenOption));

Transforms\TypeConverting.cs (2)

266Host.CheckDecode(Enum.IsDefined(typeof(InternalDataKind), kind)); 416ectx.Assert(Enum.IsDefined(typeof(InternalDataKind), kind));

Transforms\ValueToKeyMappingTransformer.cs (2)

283if (!Enum.IsDefined(typeof(ValueToKeyMappingEstimator.KeyOrdinality), options.Sort)) 290if (!Enum.IsDefined(typeof(ValueToKeyMappingEstimator.KeyOrdinality), sortOrder))

Transforms\ValueToKeyMappingTransformerImpl.cs (1)

519ectx.CheckDecode(Enum.IsDefined(typeof(MapType), mtype));

Utilities\TypeParsingUtils.cs (1)

46if (!Enum.TryParse(str, true, out dataKind))

OutputCombiners\MultiWeightedAverage.cs (3)

59Host.CheckUserArg(Enum.IsDefined(typeof(MultiWeightageKind), _weightageKind), nameof(options.WeightageName)); 69Host.CheckDecode(Enum.IsDefined(typeof(MultiWeightageKind), _weightageKind)); 87Host.Assert(Enum.IsDefined(typeof(MultiWeightageKind), _weightageKind));

OutputCombiners\WeightedAverage.cs (3)

57Host.CheckUserArg(Enum.IsDefined(typeof(WeightageKind), _weightageKind), nameof(options.WeightageName)); 66Host.CheckDecode(Enum.IsDefined(typeof(WeightageKind), _weightageKind)); 85Contracts.Assert(Enum.IsDefined(typeof(WeightageKind), _weightageKind));

Selector\SubModelSelector\BestPerformanceRegressionSelector.cs (1)

41Host.CheckUserArg(Enum.IsDefined(typeof(RegressionEvaluator.Metrics), args.MetricName), nameof(args.MetricName), "Undefined metric name");

Selector\SubModelSelector\BestPerformanceSelector.cs (1)

40Host.CheckUserArg(Enum.IsDefined(typeof(BinaryClassifierEvaluator.Metrics), args.MetricName),

Selector\SubModelSelector\BestPerformanceSelectorMulticlass.cs (1)

40Host.CheckUserArg(Enum.IsDefined(typeof(MulticlassClassificationEvaluator.Metrics), args.MetricName),

JsonUtils\JsonManifestUtils.cs (1)

365var values = Enum.GetNames(type).Where(n => type.GetField(n).GetCustomAttribute<HideEnumValueAttribute>() == null);

Dataset\IntArray.cs (2)

91Contracts.CheckParam(Enum.IsDefined(typeof(IntArrayType), type) && type != IntArrayType.Current, nameof(type)); 92Contracts.CheckParam(Enum.IsDefined(typeof(IntArrayBits), bitsPerItem), nameof(bitsPerItem));

SumupPerformanceCommand.cs (1)

89_host.CheckUserArg(Enum.IsDefined(typeof(IntArrayType), args.Type) && args.Type != IntArrayType.Current, nameof(args.Type), "Value not defined");

Utils\Timer.cs (6)

131TickTotals = new long[Enum.GetValues(typeof(TimerEvent)).Length]; 132CountTotals = new long[Enum.GetValues(typeof(CountEvent)).Length]; 136foreach (string name in Enum.GetNames(typeof(TimerEvent))) 141foreach (string name in Enum.GetNames(typeof(CountEvent))) 160foreach (TimerEvent n in Enum.GetValues(typeof(TimerEvent))) 175foreach (CountEvent n in Enum.GetValues(typeof(CountEvent)))

ImageResizer.cs (4)

207Host.CheckDecode(Enum.IsDefined(typeof(ImageResizingEstimator.ResizingKind), scale)); 209Host.CheckDecode(Enum.IsDefined(typeof(ImageResizingEstimator.Anchor), anchor)); 456Contracts.CheckUserArg(Enum.IsDefined(typeof(ResizingKind), resizing), nameof(resizing)); 457Contracts.CheckUserArg(Enum.IsDefined(typeof(Anchor), anchor), nameof(anchor));

NameFixProvider.cs (2)

56if (!Enum.TryParse(desiredNameStr, out desiredName)) 94Debug.Assert(!Enum.IsDefined(typeof(NameType), desiredName));

Parameter.cs (5)

135/// Create a <see cref="Parameter"/> from a <see cref="Enum"/> value. The <see cref="ParameterType"/> will be <see cref="ParameterType.String"/>. 138public static Parameter FromEnum<T>(T value) where T : struct, Enum 158private static Parameter FromEnum(Enum e, Type t) 160return Parameter.FromString(Enum.GetName(t, e)); 183Enum e => Parameter.FromEnum(e, e.GetType()),

ExpressionLanguageTests\ExpressionLanguageTests.cs (1)

233bool tmp = Enum.TryParse(toks[i], out kind);

SequentialAnomalyDetectionTransformBase.cs (9)

SlidingWindowTransformBase.cs (3)

74Host.CheckUserArg(Enum.IsDefined(typeof(BeginOptions), args.Begin), nameof(args.Begin), "Undefined value."); 92Host.CheckDecode(Enum.IsDefined(typeof(BeginOptions), r)); 114Host.Assert(Enum.IsDefined(typeof(BeginOptions), _begin));

SsaAnomalyDetectionBase.cs (3)

196Host.CheckUserArg(Enum.IsDefined(typeof(ErrorFunction), options.ErrorFunction), nameof(options.ErrorFunction), ErrorFunctionUtils.ErrorFunctionHelpText); 233Host.CheckDecode(Enum.IsDefined(typeof(ErrorFunction), temp)); 272Host.Assert(Enum.IsDefined(typeof(ErrorFunction), ErrorFunction));

SsaChangePointDetector.cs (1)

143InternalTransform.Host.Assert(!Enum.IsDefined(typeof(MartingaleType), InternalTransform.Martingale));

GcnTransform.cs (1)

846Contracts.CheckDecode(Enum.IsDefined(typeof(NormFunction), normKindVal));

MissingValueReplacing.cs (1)

441if (!Enum.IsDefined(typeof(ReplacementKind), kind))

OneHotEncoding.cs (2)

53if (!Enum.TryParse(extra, true, out OneHotEncodingEstimator.OutputKind kind)) 65if (!Enum.IsDefined(typeof(OneHotEncodingEstimator.OutputKind), kind))

Text\NgramTransform.cs (2)

160Contracts.CheckDecode(Enum.IsDefined(typeof(NgramExtractingEstimator.WeightingCriteria), Weighting)); 179Contracts.Assert(Enum.IsDefined(typeof(NgramExtractingEstimator.WeightingCriteria), Weighting));

Text\StopWordsRemovingTransformer.cs (4)

149var values = Enum.GetValues(typeof(StopWordsRemovingEstimator.Language)).Cast<int>(); 171var langsDictionary = Enum.GetValues(typeof(StopWordsRemovingEstimator.Language)).Cast<StopWordsRemovingEstimator.Language>() 237Contracts.CheckDecode(Enum.IsDefined(typeof(StopWordsRemovingEstimator.Language), lang)); 294foreach (StopWordsRemovingEstimator.Language lang in Enum.GetValues(typeof(StopWordsRemovingEstimator.Language)))

Text\TextFeaturizingEstimator.cs (3)

320=> (StopWordsRemovingEstimator.Language)Enum.Parse(typeof(StopWordsRemovingEstimator.Language), Language.ToString()); 385host.Check(Enum.IsDefined(typeof(Language), parent.OptionalSettings.Language)); 386host.Check(Enum.IsDefined(typeof(CaseMode), parent.OptionalSettings.CaseMode));

Text\TextNormalizing.cs (1)

164host.CheckDecode(Enum.IsDefined(typeof(TextNormalizingEstimator.CaseMode), _caseMode));

Text\WordEmbeddingsExtractor.cs (2)

187env.CheckUserArg(Enum.IsDefined(typeof(WordEmbeddingEstimator.PretrainedModelKind), modelKind), nameof(modelKind)); 227env.CheckUserArg(!options.ModelKind.HasValue || Enum.IsDefined(typeof(WordEmbeddingEstimator.PretrainedModelKind), options.ModelKind), nameof(options.ModelKind));

UngroupTransform.cs (1)

355ectx.CheckDecode(Enum.IsDefined(typeof(UngroupMode), modeIndex));

Microsoft\VisualBasic\CompilerServices\Conversions.vb (8)

Microsoft\VisualBasic\FileIO\FileSystem.vb (6)

895Debug.Assert([Enum].IsDefined(operation), "Invalid Operation") 964Debug.Assert([Enum].IsDefined(operation), "Invalid Operation") 1013Debug.Assert([Enum].IsDefined(Operation), "Invalid Operation") 1095Debug.Assert([Enum].IsDefined(operation), "Invalid Operation") 1600Debug.Assert([Enum].IsDefined(Operation)) 1601Debug.Assert([Enum].IsDefined(TargetType))

EditorConfigSettings\Common\EnumSettingViewModel.cs (1)

12where T : Enum

Options\LocalUserRegistryOptionPersister.cs (2)

104value = Enum.ToObject(optionKey.Option.Type, value); 153if (Marshal.SizeOf(Enum.GetUnderlyingType(optionType)) > Marshal.SizeOf(typeof(int)))

Options\VisualStudioSettingsOptionPersister.cs (3)

108return manager.TryGetValue(storageKey, out int value) == GetValueResult.Success ? Enum.ToObject(storageType, value) : default(Optional<object?>); 115return nullableValue.HasValue ? Enum.ToObject(underlyingType, nullableValue.Value) : null; 119return Enum.ToObject(underlyingType, value);

Telemetry\Shared\TelemetryLogger.cs (1)

94=> Enum.GetName(typeof(FunctionId), id)!.Replace('_', separator).ToLowerInvariant();

ProjectSystemShim\CSharpProjectShim.OptionsProcessor.cs (1)

127if (!Enum.TryParse(GetStringOption(CompilerOptions.OPTID_PLATFORM, ""), ignoreCase: true, result: out Platform platform))

src\VisualStudio\Core\Def\Telemetry\Shared\TelemetryLogger.cs (1)

94=> Enum.GetName(typeof(FunctionId), id)!.Replace('_', separator).ToLowerInvariant();

Options\CheckBoxEnumFlagsViewModel.cs (1)

13where TOptionValue : struct, Enum

Implementation\LanguageServer\Handler\Completion\CompletionHandler.cs (1)

192Debug.Fail($"Unhandled {nameof(XamlCompletionKind)}: {Enum.GetName(typeof(XamlCompletionKind), kind)}");

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

222[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Enum))]

netstandard.cs (1)

780[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Enum))]

Microsoft\Build\Tasks\Windows\UidManager.cs (1)

79_task = (UidTask)Enum.Parse(typeof(UidTask), _taskAsString);

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\SystemResourceKey.cs (1)

408Enum.TryParse(srkField, out SystemResourceKeyID srkId))

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

333if (Enum.TryParse(_reader.GetAttribute("OS"), out fontFamilyOsVersion)

System\Windows\Input\Command\MouseActionConverter.cs (1)

105/// Helper function similar to <see cref="Enum.IsDefined{MouseAction}(MouseAction)"/>, just lighter and faster.

System\Windows\Input\Cursor.cs (1)

327return Enum.GetName(_cursorType);

System\Windows\Input\CursorConverter.cs (1)

106CursorType ct = Enum.Parse<CursorType>(text);

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

118sn = Enum.Parse<InputScopeNameValue>(spanSource); 154return Enum.GetName(((InputScopeName)inputScope.Names[0]).NameValue);

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

101nameValue = Enum.Parse<InputScopeNameValue>(stringSource); 138return Enum.GetName(inputScopeName.NameValue);

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

823if (Enum.IsDefined(color))

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

75HttpRequestCacheLevel level = Enum.Parse<HttpRequestCacheLevel>(s, true);

System\Windows\Media\Animation\KeySplineConverter.Tests.cs (1)

304yield return new object[] { new KeySpline(0.7, 0.8, 0.9, 1.0), typeof(Enum), CultureInfo.InvariantCulture };

MS\Internal\Controls\StickyNote\StickyNoteAnnotations.cs (1)

70foreach (XmlToken val in Enum.GetValues<XmlToken>())

System\Windows\Controls\DataGridColumn.cs (1)

1155ItemsSource = Enum.GetValues(propertyType)

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

157return string.Create(CultureInfo.InvariantCulture, $"{{S@{_start}---E@{_end}}} {System.Enum.GetName(_type)}");

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

178return $"Pg{page}-nCp{_fp}-Id{_scopeId}-Tp{System.Enum.GetName(_type)}";

System\Windows\Documents\Tracing\SpellerCOMActionTraceLogger.cs (1)

157foreach (Actions a in Enum.GetValues<Actions>())

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

2510return Enum.ToObject(type.UnderlyingType, bytes).ToString();

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

12895typeof(System.Enum),

System\Windows\Markup\BamlReader.cs (1)

2456if (Enum.IsDefined(keyId))

System\Windows\Markup\BamlRecords.cs (1)

2741_valueObject = Enum.ToObject(propertyType, enumBits);

System\Windows\Markup\Primitives\ElementMarkupObject.cs (2)

927Enum enumValue = value as Enum;

System\Windows\SystemKeyConverter.cs (3)

252return $"{Enum.GetName(id)}Key"; 262string propName = $"{Enum.GetName(id)}Key"; 274return Enum.GetName(id);

System\Windows\SystemResourceKey.cs (1)

408Enum.TryParse(srkField, out SystemResourceKeyID srkId))

System\Windows\Controls\VirtualizationCacheLengthConverter.Tests.cs (1)

290yield return new object[] { new VirtualizationCacheLength(0.9, 1.0), typeof(Enum), CultureInfo.InvariantCulture };

MS\Internal\Documents\RightsManagementResourceHelper.cs (2)

114RightsManagementStatus[] statusList = Enum.GetValues<RightsManagementStatus>(); 136+ Enum.GetName(status)

MS\Internal\Documents\RMPublishingDialog.RightsTable.cs (1)

604return (RightsTableColumn)Enum.ToObject(typeof(RightsTableColumn), index);

MS\Internal\Documents\SignatureResourceHelper.cs (2)

140SignatureStatus[] statusList = Enum.GetValues<SignatureStatus>(); 162+ Enum.GetName(sigStatus)

PrintConfig\PrintSchema.cs (34)

PrintConfig\PrtCap_Public.cs (2)

55_countRootFeatures = Enum.GetNames(typeof(CapabilityName)).Length; 56_countLocalParamDefs = Enum.GetNames(typeof(PrintSchemaLocalParameterDefs)).Length;

src\Dependencies\Contracts\EnumExtensions.cs (4)

12public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 13=> Enum.GetValues<TEnum>(); 15public static string[] GetNames<TEnum>() where TEnum : struct, Enum 16=> Enum.GetNames<TEnum>();

src\Compilers\Core\Portable\InternalUtilities\EnumUtilties.cs (3)

16return (T[])Enum.GetValues(typeof(T)); 20internal static bool ContainsAllValues<T>(int mask) where T : struct, Enum, IConvertible 33internal static bool ContainsValue<T>(T value) where T : struct, Enum

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

181&& Enum.GetUnderlyingType(typeof(TValue)).GetTypeInfo().IsAssignableFrom(Enum.GetUnderlyingType(resultType).GetTypeInfo()))

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (3)

29ImmutableHashSet.CreateRange(Enum.GetValues<OutputKind>()); 146tryParseValue: static (value, out result) => Enum.TryParse(value, ignoreCase: true, result: out result), 166if (Enum.TryParse(kindStr, ignoreCase: true, result: out TEnum kind))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\CodeStyle\CodeStyleOption2`1.cs (1)

188var severity = (DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), severityAttribute.Value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (1)

480capitalizationScheme: (Capitalization)Enum.Parse(typeof(Capitalization), namingStyleElement.Attribute(nameof(CapitalizationScheme)).Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SerializableNamingRule.cs (1)

38EnforcementLevel = ((DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), namingRuleElement.Attribute(nameof(EnforcementLevel))!.Value)).ToReportDiagnostic(),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (5)

310=> (Accessibility)Enum.Parse(typeof(Accessibility), accessibilityElement.Value); 421var symbolKind = (SymbolKind)Enum.Parse(typeof(SymbolKind), symbolKindElement.Value); 433=> new((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value)); 436=> new((MethodKind)Enum.Parse(typeof(MethodKind), methodKindElement.Value)); 536=> new((ModifierKindEnum)Enum.Parse(typeof(ModifierKindEnum), modifierElement.Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (9)

104public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>() where T : struct, Enum 112public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map) where T : struct, Enum 119public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map, ImmutableDictionary<string, T> alternative) where T : struct, Enum 127public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(IEnumerable<(string name, T value)> entries, IEnumerable<(string name, T value)> alternativeEntries) where T : struct, Enum 136public static EditorConfigValueSerializer<T?> CreateSerializerForNullableEnum<T>() where T : struct, Enum 158private static bool TryParseEnum<T>(string str, out T result) where T : struct, Enum 173return Enum.TryParse(str, ignoreCase: true, out result); 209where TFromEnum : struct, Enum 210where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (1)

27=> (SpecialType)Enum.Parse(typeof(SpecialType), arg);

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

144where TFromEnum : struct, Enum 145where TToEnum : struct, Enum

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

17where TFromEnum : struct, Enum 18where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.AbstractTypeInferrer.cs (1)

119symbol.Name == nameof(Enum.HasFlag) &&

EditAndContinue\EditAndContinueTest.GenerationVerifier.cs (1)

129internal static string Inspect<TEnum>(TEnum value) where TEnum : Enum

OptionPages\PerformanceLoggersPage.cs (1)

70var functionIds = Enum.GetValues<FunctionId>().WhereAsArray(isEnabled);

UnifiedSettings\UnifiedSettingsTests.cs (2)

355(IOption2 enableWhenOption, object whenValue)? enableWhenOptionAndValue = null) where T : Enum 362var expectedEnumValues = enumValues ?? [.. Enum.GetValues(nonNullableType).Cast<T>()];

Https\HttpsTests.4.1.0.cs (1)

41factory = new ChannelFactory<IWcfService>(basicHttpsBinding, new EndpointAddress(Endpoints.Https_DefaultBinding_Address + Enum.GetName(typeof(WSMessageEncoding), messageEncoding)));

src\Dependencies\Contracts\EnumExtensions.cs (4)

12public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 13=> Enum.GetValues<TEnum>(); 15public static string[] GetNames<TEnum>() where TEnum : struct, Enum 16=> Enum.GetNames<TEnum>();

HelloWorldTest.cs (1)

72string expectedName = Enum.GetName(typeof(RuntimeArchitecture), variant.Architecture);

Throw\Throw.cs (2)

223where T : struct, Enum 226if (!Enum.IsDefined<T>(argument))

Pipe\PipeWeatherStreamFormatter.cs (1)

31if (tokens.Length < 2 || !Enum.TryParse<Weather>(tokens[1], out weather))

System\ComponentModel\DataAnnotations\DataTypeAttribute.cs (1)

18private static readonly string[] _dataTypeStrings = Enum.GetNames<DataType>();

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

77? Enum.Parse(EnumType, stringValue, false) 78: Enum.ToObject(EnumType, value); 98return Enum.IsDefined(EnumType, convertedValue); 105Convert.ChangeType(enumValue, Enum.GetUnderlyingType(enumType), CultureInfo.InvariantCulture).ToString();

System\ComponentModel\DataAnnotations\Schema\DatabaseGeneratedAttribute.cs (1)

18if (!Enum.IsDefined(databaseGeneratedOption))

Microsoft\Internal\GenerationServices.cs (1)

90rawValue = Convert.ChangeType(value, Enum.GetUnderlyingType(valueType), null);

System\ComponentModel\EnumConverter.cs (31)

15/// Provides a type converter to convert <see cref='System.Enum'/> objects to and 26if (!type.IsEnum && !type.Equals(typeof(Enum))) 44if (sourceType == typeof(string) || sourceType == typeof(Enum[])) 57if (destinationType == typeof(Enum[]) || destinationType == typeof(InstanceDescriptor)) 88bool isUnderlyingTypeUInt64 = Enum.GetUnderlyingType(EnumType) == typeof(ulong); 92convertedValue |= GetEnumValue(isUnderlyingTypeUInt64, Enum.Parse(EnumType, strValue.AsSpan(v), true), culture); 94return Enum.ToObject(EnumType, convertedValue); 98return Enum.Parse(EnumType, strValue, true); 106else if (value is Enum[]) 108bool isUnderlyingTypeUInt64 = Enum.GetUnderlyingType(EnumType) == typeof(ulong); 110foreach (Enum e in (Enum[])value) 114return Enum.ToObject(EnumType, finalValue); 130if (!EnumType.IsDefined(typeof(FlagsAttribute), false) && !Enum.IsDefined(EnumType, value)) 135return Enum.Format(EnumType, value, "G"); 149Type underlyingType = Enum.GetUnderlyingType(EnumType); 154MethodInfo? method = typeof(Enum).GetMethod("ToObject", new Type[] { typeof(Type), underlyingType }); 174if (destinationType == typeof(Enum[]) && value != null) 178bool isUnderlyingTypeUInt64 = Enum.GetUnderlyingType(EnumType) == typeof(ulong); 179List<Enum> flagValues = new List<Enum>(); 181Array objValues = Enum.GetValuesAsUnderlyingType(EnumType); 197flagValues.Add((Enum)Enum.ToObject(EnumType, ul)); 212flagValues.Add((Enum)Enum.ToObject(EnumType, longValue)); 219return new Enum[] { (Enum)Enum.ToObject(EnumType, value) }; 283value = Enum.Parse(EnumType, field.Name); 330public override bool IsValid(ITypeDescriptorContext? context, object? value) => Enum.IsDefined(EnumType, value!);

System\ComponentModel\ReflectPropertyDescriptor.cs (2)

204_defaultValue = Enum.ToObject(PropertyType, _defaultValue); 304Enum.ToObject(PropertyType, defaultValue!) :

System\ComponentModel\ReflectTypeDescriptionProvider.cs (2)

185[typeof(Enum)] = new IntrinsicTypeConverterData((type) => new EnumConverter(type), cacheConverterInstance: false), 1568converterData = IntrinsicTypeConverters[typeof(Enum)];

System\ComponentModel\ToolboxItemFilterAttribute.cs (1)

105public override string ToString() => FilterString + "," + Enum.GetName<ToolboxItemFilterType>(FilterType);

System\Configuration\GenericEnumConverter.cs (2)

38return Enum.Parse(_enumType, value); 51string names = string.Join(", ", Enum.GetNames(_enumType));

System\Diagnostics\TraceConfiguration.cs (2)

61traceSource.Switch.Level = Enum.Parse<SourceLevels>(sourceElement.SwitchValue); 80traceSource.Switch.Level = Enum.Parse<SourceLevels>(sourceElement.SwitchValue);

System\Diagnostics\TraceUtils.cs (1)

199Enum.Parse(type, value, false) :

System\Data\DataException.cs (1)

345private static Exception _InvalidEnumArgumentException<T>(T value) where T : Enum

System\Data\DataRowExtensions.cs (3)

196Type fromType = valueType.IsEnum ? Enum.GetUnderlyingType(valueType) : valueType; 197Type toType = nullableType.IsEnum ? Enum.GetUnderlyingType(nullableType) : nullableType; 199value = nullableType.IsEnum ? Enum.ToObject(nullableType, value) : Convert.ChangeType(value, nullableType, null);

System\Data\DataTable.cs (1)

3131Debug.Assert(Enum.GetUnderlyingType(typeof(DataRowState)) == typeof(int), "Invalid DataRowState type");

System\Data\DataViewManager.cs (1)

135_dataViewSettingsCollection[table]!.RowStateFilter = Enum.Parse<DataViewRowState>(r.Value);

src\libraries\Common\src\Interop\Unix\System.Native\Interop.MountPoints.FormatInfo.cs (2)

16foreach (string name in Enum.GetNames<UnixFileSystemTypes>()) 64: (Enum.GetName(typeof(UnixFileSystemTypes), formatType) ?? "");

src\libraries\Common\src\Interop\Unix\System.Native\Interop.UnixFileSystemTypes.cs (1)

160Debug.Assert(Enum.IsDefined(fileSystemType) || fstatfsResult == 0, $"GetFileSystemType returned {fstatfsResult}");

System\Diagnostics\Process.cs (1)

483if (!Enum.IsDefined(value))

System\Diagnostics\ProcessStartInfo.cs (1)

177if (!Enum.IsDefined(value))

System\Diagnostics\SourceSwitch.cs (1)

36SwitchSetting = (int)Enum.Parse<SourceLevels>(Value, true);

System\Diagnostics\TraceSwitch.cs (1)

97TraceLevel level = Enum.Parse<TraceLevel>(Value, true);

System\Drawing\FontConverter.cs (1)

239fontStyle |= Enum.Parse<FontStyle>(styleText, true);

System\Drawing\Printing\PrinterSettings.cs (1)

286if (!Enum.IsDefined(value))

System\Drawing\BitmapTests.cs (1)

1131foreach (ImageLockMode lockMode in Enum.GetValues(typeof(ImageLockMode)))

System\Drawing\PenTests.cs (2)

1008if (Enum.IsDefined(typeof(DashCap), dashCap)) 1016Assert.Equal(Enum.IsDefined(typeof(DashCap), dashCap) ? dashCap : DashCap.Flat, pen.DashCap);

System\Drawing\Printing\PrintDocumentTests.cs (1)

246Assert.True(Enum.IsDefined(typeof(PrinterResolutionKind), pageSettings.PrinterResolution.Kind));

System\Formats\Asn1\AsnDecoder.Enumerated.cs (10)

121where TEnum : Enum 125return (TEnum)Enum.ToObject( 189public static Enum ReadEnumeratedValue( 234return (Enum)Enum.ToObject(enumType, value); 255return (Enum)Enum.ToObject(enumType, value); 350public TEnum ReadEnumeratedValue<TEnum>(Asn1Tag? expectedTag = null) where TEnum : Enum 404public Enum ReadEnumeratedValue(Type enumType, Asn1Tag? expectedTag = null) 406Enum ret = AsnDecoder.ReadEnumeratedValue(_data.Span, RuleSet, enumType, out int consumed, expectedTag);

System\Formats\Asn1\AsnDecoder.NamedBitList.cs (11)

110where TFlagsEnum : Enum 114TFlagsEnum ret = (TFlagsEnum)Enum.ToObject( 177public static Enum ReadNamedBitListValue( 217Enum ret; 222ret = (Enum)Enum.ToObject(flagsEnumType, 0); 272ret = (Enum)Enum.ToObject(flagsEnumType, InterpretNamedBitListReversed(valueSpan)); 484public TFlagsEnum ReadNamedBitListValue<TFlagsEnum>(Asn1Tag? expectedTag = null) where TFlagsEnum : Enum 538public Enum ReadNamedBitListValue(Type flagsEnumType, Asn1Tag? expectedTag = null) 540Enum ret = AsnDecoder.ReadNamedBitListValue(

System\Formats\Asn1\AsnWriter.Enumerated.cs (4)

31/// <seealso cref="WriteEnumeratedValue(Enum,Asn1Tag?)"/> 33public void WriteEnumeratedValue(Enum value, Asn1Tag? tag = null) 63/// <seealso cref="WriteEnumeratedValue(Enum,Nullable{Asn1Tag})"/> 64public void WriteEnumeratedValue<TEnum>(TEnum value, Asn1Tag? tag = null) where TEnum : Enum

System\Formats\Asn1\AsnWriter.NamedBitList.cs (3)

35public void WriteNamedBitList(Enum value, Asn1Tag? tag = null) 67public void WriteNamedBitList<TEnum>(TEnum value, Asn1Tag? tag = null) where TEnum : Enum 103private void WriteNamedBitList(Asn1Tag? tag, Type tEnum, Enum value)

System\IO\Compression\ZipFile.Create.cs (1)

496if (compressionLevel.HasValue && !Enum.IsDefined(compressionLevel.Value))

src\libraries\Common\src\Interop\Unix\System.Native\Interop.MountPoints.FormatInfo.cs (2)

16foreach (string name in Enum.GetNames<UnixFileSystemTypes>()) 64: (Enum.GetName(typeof(UnixFileSystemTypes), formatType) ?? "");

src\libraries\Common\src\Interop\Unix\System.Native\Interop.UnixFileSystemTypes.cs (1)

160Debug.Assert(Enum.IsDefined(fileSystemType) || fstatfsResult == 0, $"GetFileSystemType returned {fstatfsResult}");

System\IO\FileSystemWatcher.cs (1)

67foreach (int enumValue in Enum.GetValues<NotifyFilters>())

System\IO\Packaging\InternalRelationshipCollection.cs (1)

324relationshipTargetMode = Enum.Parse<TargetMode>(targetModeAttributeValue, ignoreCase: false);

System\Dynamic\Utils\TypeUtils.cs (2)

259if (instanceType.IsEnum && AreReferenceAssignable(targetType, typeof(Enum))) 860source.IsValueType && (destination == typeof(object) || destination == typeof(ValueType)) || source.IsEnum && destination == typeof(Enum);

System\Linq\Expressions\Compiler\ILGen.cs (1)

571typeFrom == typeof(System.Enum) ||

System\Linq\Expressions\Interpreter\LightCompiler.cs (2)

1150nonNullableFrom = Enum.GetUnderlyingType(nonNullableFrom); 1155nonNullableTo = Enum.GetUnderlyingType(nonNullableTo);

System\Linq\Expressions\Interpreter\TypeOperations.cs (11)

System\Linq\Expressions\Interpreter\Utilities.cs (1)

148result = Enum.ToObject(type, result);

System\Net\Http\DiagnosticsHelper.cs (1)

75Debug.Assert(Enum.GetValues<HttpRequestError>().Length == 12, "We need to extend the mapping in case new values are added to HttpRequestError.");

src\libraries\Common\src\System\Security\Cryptography\Asn1Reader\AsnValueReader.cs (2)

120internal TFlagsEnum ReadNamedBitListValue<TFlagsEnum>(Asn1Tag? expectedTag = default) where TFlagsEnum : Enum 213internal TEnum ReadEnumeratedValue<TEnum>(Asn1Tag? expectedTag = null) where TEnum : Enum

System\Net\Security\NetSecurityTelemetry.cs (1)

183Debug.Assert(Enum.GetValues<SslProtocols>()[^1] == SslProtocols.Tls13, "Make sure to add a counter for new SslProtocols");

System\Net\WebSockets\WebSocketStateHelper.cs (1)

46Debug.Assert(Enum.IsDefined(flag));

src\libraries\Common\src\Interop\Unix\System.Native\Interop.UnixFileSystemTypes.cs (1)

160Debug.Assert(Enum.IsDefined(fileSystemType) || fstatfsResult == 0, $"GetFileSystemType returned {fstatfsResult}");

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

131internal sealed partial class EnumComparer<T> : Comparer<T>, ISerializable where T : struct, Enum

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

236public sealed partial class EnumEqualityComparer<T> : EqualityComparer<T>, ISerializable where T : struct, Enum

src\libraries\System.Private.CoreLib\src\System\ComponentModel\DefaultValueAttribute.cs (2)

59else if (type.IsSubclassOf(typeof(Enum)) && value != null) 61_value = Enum.Parse(type, value, true);

src\libraries\System.Private.CoreLib\src\System\Convert.cs (2)

212if (ReferenceEquals(targetType, typeof(Enum))) 213return (Enum)value;

src\libraries\System.Private.CoreLib\src\System\Diagnostics\CodeAnalysis\StringSyntaxAttribute.cs (1)

47/// <summary>The syntax identifier for strings containing <see cref="Enum"/> format specifiers.</summary>

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipePayloadDecoder.cs (1)

30Type? enumType = parameterType.IsEnum ? Enum.GetUnderlyingType(parameterType) : null;

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

412if (data is Enum) 416Type underlyingType = Enum.GetUnderlyingType(data.GetType());

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (5)

1241public static implicit operator EventSourcePrimitive(Enum value) => new(value); 3071value = Enum.Parse(p.PropertyType, val); 5541if (type.IsEnum && Enum.GetUnderlyingType(type) != typeof(ulong) && Enum.GetUnderlyingType(type) != typeof(long)) 5663if (Enum.IsDefined(attribs.EventChannelType))

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

177type = Enum.GetUnderlyingType(type); 228type = Enum.GetUnderlyingType(type);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\Statics.cs (1)

486dataType = Enum.GetUnderlyingType(dataType);

src\libraries\System.Private.CoreLib\src\System\Enum.cs (21)

src\libraries\System.Private.CoreLib\src\System\Environment.GetFolderPathCore.Unix.cs (1)

146if (!Enum.IsDefined(folder))

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.cs (2)

6114if (Enum.TryFormatUnconstrained(value, _destination.Slice(_pos), out int charsWritten)) 6175if (Enum.TryFormatUnconstrained(value, _destination.Slice(_pos), out int charsWritten, format))

src\libraries\System.Private.CoreLib\src\System\Reflection\CustomAttributeTypedArgument.cs (1)

99private static object? CanonicalizeValue(object? value) => (value is Enum e) ? e.GetValue() : value;

src\libraries\System.Private.CoreLib\src\System\Reflection\Emit\Opcode.cs (1)

117name = Enum.GetName(opCodeValue)!.ToLowerInvariant().Replace('_', '.');

src\libraries\System.Private.CoreLib\src\System\Reflection\InvokeUtils.cs (9)

src\libraries\System.Private.CoreLib\src\System\Reflection\MethodBase.cs (1)

160arg = Enum.ToObject(argumentType, arg);

src\libraries\System.Private.CoreLib\src\System\Resources\NeutralResourcesLanguageAttribute.cs (1)

24if (!Enum.IsDefined(location))

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\DefaultInterpolatedStringHandler.cs (2)

270while (!Enum.TryFormatUnconstrained(value, _chars.Slice(_pos), out charsWritten)) 337while (!Enum.TryFormatUnconstrained(value, _chars.Slice(_pos), out charsWritten, format))

src\libraries\System.Private.CoreLib\src\System\RuntimeType.cs (22)

src\libraries\System.Private.CoreLib\src\System\Text\StringBuilder.cs (2)

2892if (Enum.TryFormatUnconstrained(value, _stringBuilder.RemainingCurrentChunk, out int charsWritten)) 2963if (Enum.TryFormatUnconstrained(value, _stringBuilder.RemainingCurrentChunk, out int charsWritten, format))

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8.cs (2)

734return Enum.TryFormatUnconstrained(value, utf16, out int charsWritten, format) ? 757if (Enum.TryFormatUnconstrained(value, array, out charsWritten, format))

src\libraries\System.Private.CoreLib\src\System\Type.cs (1)

126public virtual bool IsEnum { [Intrinsic] get => IsSubclassOf(typeof(Enum)); }

src\libraries\System.Private.CoreLib\src\System\Type.Enum.cs (2)

160ulArray[i] = Enum.ToUInt64(array.GetValue(i)!); 162ulong ulValue = Enum.ToUInt64(value);

src\libraries\System.Private.CoreLib\src\System\Type.Helpers.cs (1)

30if (underlyingType == typeof(Delegate) || underlyingType == typeof(Enum))

src\System\Collections\Generic\Comparer.CoreCLR.cs (1)

15internal sealed partial class EnumComparer<T> : Comparer<T> where T : struct, Enum

src\System\Collections\Generic\EqualityComparer.CoreCLR.cs (1)

162public sealed partial class EnumEqualityComparer<T> : EqualityComparer<T> where T : struct, Enum

src\System\Reflection\Emit\CustomAttributeBuilder.cs (2)

254return Type.GetTypeCode(Enum.GetUnderlyingType(t)) is 375switch (Type.GetTypeCode(Enum.GetUnderlyingType(type)))

src\System\Reflection\Emit\RuntimeEnumBuilder.cs (1)

308m_typeBuilder = new RuntimeTypeBuilder(name, visibility | TypeAttributes.Sealed, typeof(Enum), null, module, PackingSize.Unspecified, TypeBuilder.UnspecifiedTypeSize, null);

src\System\Reflection\Emit\RuntimeTypeBuilder.cs (1)

236underlyingType = Enum.GetUnderlyingType(destType);

src\System\Reflection\MdConstant.cs (1)

75return Enum.ToObject(fieldType, defaultValue);

src\System\Reflection\RuntimeCustomAttributeData.cs (3)

167if (type == typeof(Enum)) 503CustomAttributeEncoding.Enum => typeof(Enum), 1096encodedEnumType = RuntimeCustomAttributeData.TypeToCustomAttributeEncoding((RuntimeType)Enum.GetUnderlyingType(parameterType));

src\System\Runtime\CompilerServices\RuntimeHelpers.CoreCLR.cs (2)

364internal static bool EnumEquals<T>(T x, T y) where T : struct, Enum 372internal static int EnumCompareTo<T>(T x, T y) where T : struct, Enum

src\System\RuntimeType.CoreCLR.cs (3)

3413return IsSubclassOf(typeof(Enum)); 3415bool isEnum = th.AsMethodTable()->ParentMethodTable == Runtime.CompilerServices.TypeHandle.TypeHandleOf<Enum>().AsMethodTable(); 3429bool isEnum = !th.IsTypeDesc && th.AsMethodTable()->ParentMethodTable == Runtime.CompilerServices.TypeHandle.TypeHandleOf<Enum>().AsMethodTable();

System\Runtime\Serialization\CodeGenerator.cs (3)

807Ldc(Convert.ChangeType(o, Enum.GetUnderlyingType(valueType), null)); 985Ldelem(Enum.GetUnderlyingType(arrayElementType)); 1024Stelem(Enum.GetUnderlyingType(arrayElementType));

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

663"Enum" => typeof(Enum), 750else if (type == typeof(Enum) || type == typeof(ValueType))

System\Runtime\Serialization\EnumDataContract.cs (3)

129Type baseType = Enum.GetUnderlyingType(type); 372return Enum.ToObject(UnderlyingType, (object)(ulong)longValue); 373return Enum.ToObject(UnderlyingType, (object)longValue);

System\Runtime\Serialization\Json\JsonEnumDataContract.cs (2)

30enumValue = Enum.ToObject(TraditionalDataContract.UnderlyingType, jsonReader.ReadElementContentAsUnsignedLong()); 34enumValue = Enum.ToObject(TraditionalDataContract.UnderlyingType, jsonReader.ReadElementContentAsLong());

System\Runtime\Serialization\Json\JsonFormatGeneratorStatics.cs (1)

481s_parseEnumMethod = typeof(Enum).GetMethod("Parse", BindingFlags.Static | BindingFlags.Public, new Type[] { typeof(Type), typeof(string) });

System\Runtime\Serialization\Json\ReflectionJsonFormatReader.cs (1)

205pairKey = Enum.Parse(keyType, keyString);

System\Runtime\Serialization\Json\XmlObjectSerializerWriteContextComplexJson.cs (1)

124if (declaredContract.UnderlyingType == typeof(Enum))

XUnit\EnumDataAttribute.cs (2)

9public class EnumDataAttribute<TEnum> : CommonMemberDataAttribute where TEnum : struct, Enum 13public static ReadOnlyTheoryData TheoryData { get; } = new(Enum.GetValues<TEnum>());

XUnit\InvalidEnumDataAttribute.cs (4)

12public class InvalidEnumDataAttribute<TEnum> : CommonMemberDataAttribute where TEnum : unmanaged, Enum 33defined = Enum.IsDefined(currentValue); 53defined = Enum.IsDefined(currentValue); 63defined = Enum.IsDefined(currentValue);

System\Xml\Serialization\CodeGenerator.cs (3)

778Ldc(Convert.ChangeType(o, Enum.GetUnderlyingType(valueType), null)); 1034Ldelem(Enum.GetUnderlyingType(arrayElementType)); 1081Stelem(Enum.GetUnderlyingType(arrayElementType));

System\Xml\Serialization\ReflectionXmlSerializationReader.cs (3)

1270return Enum.ToObject(mapping.TypeDesc!.Type!, ToEnum(source, table, mapping.TypeDesc.Name)); 1278return Enum.Parse(mapping.TypeDesc!.Type!, c.Name); 1750object choiceValue = Enum.Parse(choice.Mapping!.TypeDesc!.Type!, name);

System\Xml\Serialization\SoapReflectionImporter.cs (2)

752string strValue = Enum.Format(a.SoapDefaultValue.GetType(), a.SoapDefaultValue, "G").Replace(",", " "); 753string numValue = Enum.Format(a.SoapDefaultValue.GetType(), a.SoapDefaultValue, "D");

System\Xml\Serialization\XmlReflectionImporter.cs (2)

2160string strValue = Enum.Format(t, a.XmlDefaultValue, "G").Replace(",", " "); 2161string numValue = Enum.Format(t, a.XmlDefaultValue, "D");

System\Xml\Serialization\XmlSerializationReader.cs (1)

3005Writer.Write(typeof(Enum).FullName);

System\Xml\Serialization\XmlSerializationReaderILGen.cs (3)

992ilg.Ldc(Enum.ToObject(mapping.TypeDesc!.Type!, constants[i].Value)); 1029underlyingType = Enum.GetUnderlyingType(returnType); 1095retValues.Add(Enum.ToObject(mapping.TypeDesc.Type!, c.Value));

System\Xml\Serialization\XmlSerializationWriterILGen.cs (5)

222ilg.Ldc(Enum.Parse(mapping.TypeDesc.Type!, enumDefaultValue!, false)); 634ilg.Ldc(Enum.ToObject(mapping.TypeDesc.Type!, c.Value)); 2253eValue = Enum.ToObject(choiceMapping.TypeDesc!.Type!, choiceMapping.Constants[i].Value); 2267eValue = Enum.ToObject(choiceMapping.TypeDesc!.Type!, choiceMapping.Constants[i].Value); 2342ilg.Ldc(Enum.Parse(type, memberName, false));

System\Xml\Xsl\IlGen\OptimizerPatterns.cs (3)

57private static readonly int s_patternCount = Enum.GetValues<OptimizerPatternName>().Length; 245Debug.Assert(Enum.IsDefined(pattern)); 256Debug.Assert(Enum.IsDefined(pattern));

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

182string s = Enum.GetName(typeof(XmlILOptimization), opt)!;

System\Xml\Xsl\QIL\QilXmlWriter.cs (2)

209this.writer.WriteStartElement(Enum.GetName(n.NodeType)!); 280this.writer.WriteStartElement("", Enum.GetName(node.NodeType)!, "");

System\Xml\Xsl\Runtime\XmlExtensionFunction.cs (1)

330return Enum.GetUnderlyingType(clrType);

System\Xml\Xsl\XmlQueryTypeFactory.cs (1)

350XmlTypeCode[] arrEnum = Enum.GetValues<XmlTypeCode>();

System\Reflection\Emit\EnumBuilderImpl.cs (1)

19_typeBuilder = new TypeBuilderImpl(name, visibility | TypeAttributes.Sealed, typeof(Enum), module,

System\Reflection\Metadata\BlobWriterImpl.cs (2)

159type = Enum.GetUnderlyingType(type); 232type = Enum.GetUnderlyingType(type);

System\Reflection\Metadata\Ecma335\Encoding\BlobEncoders.cs (1)

598/// <see cref="Enum"/> (encoded as the underlying integer value).

src\libraries\Common\src\System\Resources\ResourceWriter.cs (1)

474ResourceTypeCode typeCode = Enum.Parse<ResourceTypeCode>(typeName);

src\libraries\Common\src\System\Resources\ResourceWriter.cs (1)

474ResourceTypeCode typeCode = Enum.Parse<ResourceTypeCode>(typeName);

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

178[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Enum))]

src\libraries\Common\src\System\Security\Cryptography\Asn1Reader\AsnValueReader.cs (2)

120internal TFlagsEnum ReadNamedBitListValue<TFlagsEnum>(Asn1Tag? expectedTag = default) where TFlagsEnum : Enum 213internal TEnum ReadEnumeratedValue<TEnum>(Asn1Tag? expectedTag = null) where TEnum : Enum

src\libraries\Common\src\System\Security\Cryptography\Asn1Reader\AsnValueReader.cs (2)

120internal TFlagsEnum ReadNamedBitListValue<TFlagsEnum>(Asn1Tag? expectedTag = default) where TFlagsEnum : Enum 213internal TEnum ReadEnumeratedValue<TEnum>(Asn1Tag? expectedTag = null) where TEnum : Enum

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

369if (!Enum.IsDefined(typeof(SecurityKeyEntropyMode), value))

System\ServiceModel\Channels\SslProtocolsHelper.cs (1)

14foreach (var protocol in Enum.GetValues(typeof(SslProtocols)))

System\ServiceModel\Channels\SslProtocolsHelper.cs (1)

14foreach (var protocol in Enum.GetValues(typeof(SslProtocols)))

Extensions\ReflectionExtensions.cs (1)

203return GetTypeCode(Enum.GetUnderlyingType(type));

System\ServiceModel\Description\PrincipalPermissionMode.cs (1)

21return Enum.IsDefined(typeof(PrincipalPermissionMode), principalPermissionMode);

System\ServiceModel\Channels\SslProtocolsHelper.cs (1)

14foreach (var protocol in Enum.GetValues(typeof(SslProtocols)))

System\Text\Encodings\Web\ThrowHelper.cs (1)

25Debug.Assert(Enum.IsDefined(typeof(ExceptionArgument), argument),

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

308return Enum.ToObject(parameterType, defaultValue); 313return Enum.ToObject(underlyingType, defaultValue);

System\Text\Json\Serialization\Converters\Value\EnumConverter.cs (5)

17where T : struct, Enum 269success = Enum.TryParse(source, out result); 400s_isFlagsEnum || (dictionaryKeyPolicy is not null && Enum.IsDefined(typeof(T), value)), 517string[] names = Enum.GetNames<T>(); 518T[] values = Enum.GetValues<T>();

System\Text\Json\Serialization\Converters\Value\EnumConverterFactory.cs (1)

57where T : struct, Enum

System\Text\Json\Serialization\JsonNumberEnumConverter.cs (1)

18where TEnum : struct, Enum

System\Text\Json\Serialization\JsonStringEnumConverter.cs (1)

17where TEnum : struct, Enum

System\Text\Json\Serialization\Metadata\JsonMetadataServices.Converters.cs (1)

283public static JsonConverter<T> GetEnumConverter<T>(JsonSerializerOptions options) where T : struct, Enum

Helpers\SourceGeneratorHelpers.cs (1)

13public static string FormatEnumLiteral<TEnum>(string fullyQualifiedName, TEnum value) where TEnum : struct, Enum

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

31Debug.Assert(!Enum.IsDefined(BeforeChild)); 32Debug.Assert(!Enum.IsDefined(AfterChild));

System\Text\RegularExpressions\Symbolic\RegexNodeConverter.cs (2)

378Debug.Assert(!Enum.IsDefined((UnicodeCategory)UnicodeCategoryCount)); 523Debug.Assert(Enum.IsDefined(code) || code == (UnicodeCategory)(RegexCharClass.SpaceConst - 1), $"Unknown category: {code}");

System\Text\RegularExpressions\Symbolic\UnicodeCategoryConditions.cs (1)

28Debug.Assert(Enum.GetValues<UnicodeCategory>().Length == UnicodeCategoryValueCount);

System\Text\RegularExpressions\Symbolic\UnicodeCategoryRangesGenerator.cs (1)

42foreach (UnicodeCategory c in Enum.GetValues<UnicodeCategory>())

System\Windows\Forms\ActiveX\AxHost.AxPropertyDescriptor.cs (1)

226_baseDescriptor.SetValue(component, Enum.ToObject(PropertyType, value));

System\Windows\Forms\ComponentModel\COM2Interop\COM2EnumConverter.cs (1)

35? Enum.ToObject(destinationType, value)

System\Windows\Forms\ComponentModel\COM2Interop\Com2IPerPropertyBrowsingHandler.Com2IPerPropertyBrowsingEnum.cs (1)

114valueItems[i] = Enum.ToObject(targetType, valueItems[i]);

System\Windows\Forms\ComponentModel\COM2Interop\COM2PropertyDescriptor.cs (1)

660_lastValue = Enum.ToObject(_propertyType, _lastValue);

System\Windows\Forms\Controls\DataGridView\DataGridViewBand.cs (1)

495if (!Enum.IsDefined(value))

System\Windows\Forms\Controls\DataGridView\DataGridViewCellStyle.cs (1)

97Debug.Assert(Enum.IsDefined(value));

System\Windows\Forms\Controls\DataGridView\DataGridViewHeaderCell.cs (1)

564Debug.Assert(Enum.IsDefined(newButtonState));

System\Windows\Forms\Controls\ListView\ListView.ListViewAccessibleObject.cs (1)

14private static readonly int[] s_enumViewValues = (int[])Enum.GetValues(typeof(View));

System\Windows\Forms\Controls\ListView\ListViewItem.IKeyboardToolTip.cs (1)

34foreach (SearchDirectionHint searchDirectionHint in Enum.GetValues(typeof(SearchDirectionHint)))

System\Windows\Forms\Controls\WebBrowser\WebBrowser.WebBrowserSite.cs (1)

165if (lpMsg->message != PInvokeCore.WM_CHAR && Enum.IsDefined((Shortcut)keyCode))

System\Windows\Forms\Input\KeyEventArgs.cs (1)

48if (!Enum.IsDefined(keyGenerated))

System\Windows\Forms\Input\KeysConverter.cs (12)

130=> sourceType == typeof(string) || sourceType == typeof(Enum[]) || base.CanConvertFrom(context, sourceType); 137=> destinationType == typeof(Enum[]) || base.CanConvertTo(context, destinationType); 174currentKey = (Keys)Enum.Parse(typeof(Keys), token); 198if (value is Enum[] valueAsEnumArray) 201foreach (Enum e in valueAsEnumArray) 206return Enum.ToObject(typeof(Keys), finalValue); 230: destinationType == typeof(Enum[]) 234Enum[] GetTermKeys(Keys key) 236List<Enum> termKeys = []; 274if (!foundKey && Enum.IsDefined(keyOnly)) 322if (!foundKey && Enum.IsDefined(keyOnly)) 324termStrings.Append(Enum.GetName(keyOnly));

System\Windows\Forms\Input\PreviewKeyDownEventArgs.cs (1)

38if (!Enum.IsDefined(keyGenerated))

System\Windows\Forms\Panels\TableLayoutPanel\TableLayoutSettingsTypeConverter.cs (1)

197SizeType type = (SizeType)Enum.Parse(sizeTypeType, styleString.AsSpan(currentIndex, nextIndex - currentIndex), true);

System\Windows\Forms\CSharp\Generators\ApplicationConfiguration\ProjectFileReader.cs (2)

111if (!Enum.TryParse(rawValue, true, out highDpiMode) || 112!Enum.IsDefined(typeof(HighDpiMode), highDpiMode))

System\Windows\Forms\CSharp\Generators\ApplicationConfiguration\ProjectFileReader.FontConverter.cs (1)

104fontStyle |= (FontStyle)Enum.Parse(typeof(FontStyle), styleText, true);

Generators\ApplicationConfigurationGenerator\ApplicationConfigurationGeneratorTests.cs (1)

48foreach (OutputKind projectType in Enum.GetValues(typeof(OutputKind)))

Analyzers\AppManifestAnalyzer\FontStyleTests.cs (2)

14var values = Enum.GetValues(typeof(FontStyle)); 26FontStyle value = Enum.Parse<FontStyle>(input);

Analyzers\AppManifestAnalyzer\GraphicsUnitTests.cs (2)

15var values = Enum.GetValues<GraphicsUnit>(); 29GraphicsUnit value = Enum.Parse<GraphicsUnit>(input);

System\ComponentModel\Design\Serialization\CodeDomSerializationProvider.cs (1)

68if (typeof(Enum).IsAssignableFrom(objectType))

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

1406if (result != left && left is Enum) 1409result = Enum.ToObject(left.GetType(), result);

System\ComponentModel\Design\Serialization\EnumCodeDomSerializer.cs (6)

27if (value is not Enum enumValue) 34Enum[] values; 36if (converter is not null && converter.CanConvertTo(typeof(Enum[]))) 38values = (Enum[])converter.ConvertTo(enumValue, typeof(Enum[]))!; 61foreach (Enum term in values)

System\ComponentModel\Design\ByteViewerTests.cs (1)

455foreach (DisplayMode displayMode in Enum.GetValues(typeof(DisplayMode)))

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

93foreach (object type in Enum.GetValues(typeof(SnapLineType)))

System\EnumExtensions.cs (1)

19public static unsafe void ChangeFlags<T>(ref this T value, T flags, bool set) where T : unmanaged, Enum

System\Windows\Forms\Internals\ScaleHelper.cs (1)

86Debug.Assert(Enum.IsDefined(processDpiAwareness));

System\Windows\Forms\Automation\UiaTextRangeTests.cs (1)

401Array textAttributeIdentifiers = Enum.GetValues(typeof(UIA_TEXTATTRIBUTE_ID));

Metafiles\RecordTypes\EMRENUMRECORD.cs (1)

26internal struct EMRENUMRECORD<T> where T : Enum

MaskedTextBoxTests.cs (1)

440if (!Enum.IsDefined(typeof(InsertKeyMode), insertMode))

System\Windows\Forms\AccessibleObjects\Button.ButtonAccessibleObjectTests.cs (1)

103Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ButtonBase.ButtonBaseAccessibleObjectTests.cs (1)

211Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\CheckBox.CheckBoxAccessibleObjectTests.cs (1)

283Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\CheckedListBoxAccessibleObjectTests.cs (1)

62Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ComboBox.ComboBoxAccessibleObjectTests.cs (3)

128foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle))) 169foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle))) 243Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ComboBox.ComboBoxItemAccessibleObjectTests.cs (4)

236foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle))) 279foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle))) 367foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle))) 422foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))

System\Windows\Forms\AccessibleObjects\Control.ControlAccessibleObjectTests.cs (1)

1403Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\DataGridView.DataGridViewEditingPanelAccessibleObjectTests.cs (1)

83Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\DataGridViewAccessibleObjectTests.cs (1)

485Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\DataGridViewComboBoxCellAccessibleObjectTests.cs (2)

14foreach (DataGridViewComboBoxDisplayStyle displayStyle in Enum.GetValues(typeof(DataGridViewComboBoxDisplayStyle))) 45foreach (DataGridViewComboBoxDisplayStyle displayStyle in Enum.GetValues(typeof(DataGridViewComboBoxDisplayStyle)))

System\Windows\Forms\AccessibleObjects\DataGridViewComboBoxEditingControlAccessibleObjectTests.cs (1)

58Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\DataGridViewTextBoxEditingControl.DataGridViewTextBoxEditingControlAccessibleObjectTests.cs (1)

94Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\DateTimePicker.DateTimePickerAccessibleObjectTests.cs (1)

64Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\DomainUpDownAccessibleObjectTests.cs (1)

70Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\Form.FormAccessibleObjectTests.cs (1)

77Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\GroupBoxAccessibleObjectTests.cs (1)

97Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\HScrollBar.HScrollBarAccessibleObjectTests.cs (1)

85Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\LabelAccessibleObjectTests.cs (1)

100Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\LinkLabel.LinkLabelAccessibleObjectTests.cs (1)

36Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ListBoxAccessibleObjectTests.cs (1)

60Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ListVIew.ListViewAccessibleObjectTests.cs (7)

232foreach (View view in Enum.GetValues(typeof(View))) 316foreach (View view in Enum.GetValues(typeof(View))) 481foreach (View view in Enum.GetValues(typeof(View))) 902foreach (View view in Enum.GetValues(typeof(View))) 988foreach (View view in Enum.GetValues(typeof(View))) 1113Array roles = Enum.GetValues(typeof(AccessibleRole)); 1236foreach (View view in Enum.GetValues(typeof(View)))

System\Windows\Forms\AccessibleObjects\ListViewGroup.ListViewGroupAccessibleObjectTests.cs (6)

353foreach (View view in Enum.GetValues(typeof(View))) 537foreach (View view in Enum.GetValues(typeof(View))) 559foreach (View view in Enum.GetValues(typeof(View))) 636foreach (View view in Enum.GetValues(typeof(View))) 1299foreach (View view in Enum.GetValues(typeof(View))) 1305foreach (ListViewGroupCollapsedState listViewGroupCollapsedState in Enum.GetValues(typeof(ListViewGroupCollapsedState)))

System\Windows\Forms\AccessibleObjects\ListViewItem.ListViewItemAccessibleObjectTests.cs (13)

System\Windows\Forms\AccessibleObjects\MaskedTextBox.MaskedTextBoxAccessibleObjectTests.cs (1)

51Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\MenuStrip.MenuStripAccessibleObjectTests.cs (7)

114Array roles = Enum.GetValues(typeof(AccessibleRole)); 143Array directions = Enum.GetValues<NavigateDirection>(); 499foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>()) 516foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>()) 736foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>()) 777foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>()) 877foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())

System\Windows\Forms\AccessibleObjects\MonthCalendar.MonthCalendarAccessibleObjectTests.cs (1)

52Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\NumericUpDownAccessibleObjectTests.cs (1)

68Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\Panel.PanelAccessibleObjectTests.cs (1)

92Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\PictureBox.PictureBoxAccessibleObjectTests.cs (1)

125Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ProgressBarAccessibleObjectTests.cs (1)

126Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\PropertyGrid.PropertyGridAccessibleObjectTests.cs (1)

83Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\RadioButton.RadioButtonAccessibleObjectTests.cs (1)

229Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ScrollBar.ScrollBarAccessibleObjectTests.cs (1)

79Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\SplitContainer.SplitContainerAccessibleObjectTests.cs (1)

50Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\Splitter.SplitterAccessibleObjectTests.cs (1)

130Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\StatusStrip.StatusStripAccessibleObjectTests.cs (7)

94Array roles = Enum.GetValues(typeof(AccessibleRole)); 123Array directions = Enum.GetValues<NavigateDirection>(); 479foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>()) 496foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>()) 716foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>()) 757foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>()) 858foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())

System\Windows\Forms\AccessibleObjects\TabControl.TabControlAccessibleObjectTests.cs (1)

53Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\TabPage.TabPageAccessibleObjectTests.cs (1)

56Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\TextBoxAccessibleObjectTests.cs (1)

68Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\TextBoxBaseAccessibleObjectTests.cs (1)

141Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ToolStripAccessibleObjectTests.cs (7)

92Array roles = Enum.GetValues(typeof(AccessibleRole)); 121Array directions = Enum.GetValues<NavigateDirection>(); 492foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>()) 509foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>()) 729foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>()) 770foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>()) 870foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())

System\Windows\Forms\AccessibleObjects\ToolStripButton.ToolStripButtonAccessibleObjectTests.cs (1)

72Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ToolStripComboBox.ToolStripComboBoxControl.ToolStripComboBoxControlAccessibleObjectTests.cs (1)

44Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ToolStripDropDown.ToolStripDropDownAccessibleObjectTests.cs (1)

51Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ToolStripDropDownButton.ToolStripDropDownButtonAccessibleObjectTests.cs (1)

47Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ToolStripGrip.ToolStripGripAccessibleObjectTests.cs (1)

46Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ToolStripItemAccessibleObjectTests.cs (1)

145Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ToolStripLabel.ToolStripLabelAccessibleObjectTests.cs (1)

53Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ToolStripMenuItem.ToolStripMenuItemAccessibleObjectTests.cs (1)

93Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ToolStripNumericUpDown.ToolStripNumericUpDownAccessibleObjectTests.cs (1)

57Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ToolStripOverflow.ToolStripOverflowAccessibleObjectTests.cs (1)

53Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ToolStripOverflowButton.ToolStripOverflowButtonAccessibleObjectTests.cs (1)

52Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ToolStripProgressBar.ToolStripProgressBarControl.ToolStripProgressBarControlAccessibleObjectTests.cs (1)

56Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ToolStripSeparator.ToolStripSeparatorAccessibleObjectTests.cs (1)

46Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ToolStripSplitButton.ToolStripSplitButtonAccessibleObjectTests.cs (1)

46Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ToolStripStatusLabel.ToolStripStatusLabelAccessibleObjectTests.cs (1)

52Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\ToolStripTextBox.ToolStripTextBoxControlAccessibleObjectTests.cs (1)

113Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\TrackBar.TrackBarAccessibleObjectTests.cs (1)

284Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\TrackBar.TrackBarFirstButtonAccessibleObjectTests.cs (1)

104foreach (Orientation orientation in Enum.GetValues(typeof(Orientation)))

System\Windows\Forms\AccessibleObjects\TrackBar.TrackBarLastButtonAccessibleObjectTests.cs (1)

104foreach (Orientation orientation in Enum.GetValues(typeof(Orientation)))

System\Windows\Forms\AccessibleObjects\UpDownBase.UpDownButtons.UpDownButtonsAccessibleObjectTests.cs (1)

56Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\UpDownBase.UpDownEdit.UpDownEditAccessibleObjectTests.cs (1)

170Array roles = Enum.GetValues(typeof(AccessibleRole));

System\Windows\Forms\AccessibleObjects\VScrollBar.VScrollBarAccessibleObjectTests.cs (1)

84Array roles = Enum.GetValues(typeof(AccessibleRole));

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

14Array roles = Enum.GetValues(typeof(AccessibleRole));

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

116Assert.True(Enum.IsDefined(state)); 129VisualStyleState value = Enum.Parse<VisualStyleState>(valueString);

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

538foreach (ControlUpdateMode controlUpdateMode in Enum.GetValues(typeof(ControlUpdateMode))) 584foreach (ControlUpdateMode controlUpdateMode in Enum.GetValues(typeof(ControlUpdateMode)))

System\Windows\Forms\ButtonBaseTests.cs (33)

System\Windows\Forms\ButtonTests.cs (5)

206foreach (ContentAlignment textAlign in Enum.GetValues(typeof(ContentAlignment))) 1807foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle))) 2643foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle))) 2695foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle))) 2798foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))

System\Windows\Forms\ComboBox.ComboBoxChildDropDownButtonUiaProviderTests.cs (1)

14foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))

System\Windows\Forms\ComboBox.ComboBoxChildEditUiaProviderTests.cs (2)

15foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle))) 63foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))

System\Windows\Forms\ComboBox.ComboBoxChildListUiaProviderTests.cs (2)

15foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle))) 87foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))

System\Windows\Forms\ComboBox.ComboBoxChildNativeWindowTests.cs (1)

19foreach (object childWindowType in Enum.GetValues(childWindowTypeEnum))

System\Windows\Forms\ComboBox.ComboBoxUiaTextProviderTests.cs (7)

324foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle))) 480foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle))) 518foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle))) 557foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle))) 607foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle))) 760foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle))) 802foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))

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

841foreach (AutoCompleteSource source in Enum.GetValues(typeof(AutoCompleteSource))) 843foreach (AutoCompleteMode mode in Enum.GetValues(typeof(AutoCompleteMode)))

System\Windows\Forms\CommonDialogTests.cs (3)

130DialogResult expectedDialogResult = (DialogResult)Enum.Parse(typeof(DialogResult), expectedDialogResultString); 168DialogResult expectedDialogResult = (DialogResult)Enum.Parse(typeof(DialogResult), expectedDialogResultString); 204DialogResult expectedDialogResult = (DialogResult)Enum.Parse(typeof(DialogResult), expectedDialogResultString);

System\Windows\Forms\ControlPaintTests.cs (14)

System\Windows\Forms\ControlTests.Handlers.cs (4)

3840foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout))) 3903foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout))) 3947foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout))) 4075foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout)))

System\Windows\Forms\ControlTests.Methods.ClipboardTests.cs (1)

18foreach (DragDropEffects allowedEffects in Enum.GetValues(typeof(DragDropEffects)))

System\Windows\Forms\ControlTests.Methods.cs (12)

System\Windows\Forms\ControlTests.Properties.cs (3)

738foreach (DockStyle dock in Enum.GetValues(typeof(DockStyle))) 4319foreach (AnchorStyles anchor in Enum.GetValues(typeof(AnchorStyles))) 4321foreach (DockStyle value in Enum.GetValues(typeof(DockStyle)))

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

145foreach (DataGridViewAutoSizeColumnsMode columnsAutoSizeMode in Enum.GetValues(typeof(DataGridViewAutoSizeColumnsMode))) 147foreach (DataGridViewAutoSizeColumnMode autoSizeMode in Enum.GetValues(typeof(DataGridViewAutoSizeColumnMode)))

System\Windows\Forms\DataGridViewColumnTests.cs (8)

System\Windows\Forms\DataGridViewHeaderCellTests.cs (11)

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

1926foreach (DataGridViewAutoSizeRowsMode autoSizeRowsMode in Enum.GetValues(typeof(DataGridViewAutoSizeRowsMode))) 2395foreach (DataGridViewAutoSizeRowsMode autoSizeRowsMode in Enum.GetValues(typeof(DataGridViewAutoSizeRowsMode)))

System\Windows\Forms\DataGridViewTests.cs (4)

500foreach (DataGridViewColumnHeadersHeightSizeMode value in Enum.GetValues(typeof(DataGridViewColumnHeadersHeightSizeMode))) 1428foreach (DataGridViewRowHeadersWidthSizeMode value in Enum.GetValues(typeof(DataGridViewRowHeadersWidthSizeMode))) 1910foreach (DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode in Enum.GetValues(typeof(DataGridViewColumnHeadersHeightSizeMode))) 2391foreach (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode in Enum.GetValues(typeof(DataGridViewRowHeadersWidthSizeMode)))

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

1031foreach (ErrorBlinkStyle blinkStyle in Enum.GetValues(typeof(ErrorBlinkStyle))) 1126foreach (ErrorBlinkStyle blinkStyle in Enum.GetValues(typeof(ErrorBlinkStyle)))

System\Windows\Forms\FormTests.cs (3)

1891foreach (DialogResult dialogResult in Enum.GetValues(typeof(DialogResult))) 1928foreach (DialogResult dialogResult in Enum.GetValues(typeof(DialogResult))) 2158foreach (DialogResult dialogResult in Enum.GetValues(typeof(DialogResult)))

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

1829foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))

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

36if (Enum.IsDefined(typeof(Keys), e.KeyValue))

System\Windows\Forms\KeysConverterTests.cs (11)

46yield return new object[] { "fr-FR", Keys.None, new Enum[] { Keys.None } }; 47yield return new object[] { "de-DE", Keys.S, new Enum[] { Keys.S } }; 48yield return new object[] { "zh-CN", Keys.Control | Keys.C, new Enum[] { Keys.Control, Keys.C } }; 49yield return new object[] { "it-IT", Keys.Control | Keys.Add, new Enum[] { Keys.Control, Keys.Add } }; 50yield return new object[] { "ko-KR", Keys.Control | Keys.Alt | Keys.D, new Enum[] { Keys.Control, Keys.Alt, Keys.D } }; 51yield return new object[] { "ru-RU", Keys.Control | Keys.Alt | Keys.Shift | Keys.A, new Enum[] { Keys.Control, Keys.Alt, Keys.Shift, Keys.A } }; 52yield return new object[] { "zh-TW", Keys.Control | Keys.Alt | Keys.Shift | Keys.F1, new Enum[] { Keys.Control, Keys.Alt, Keys.Shift, Keys.F1 } }; 57public void ConvertToEnumArray_ShouldConvertKeys(string cultureName, Keys keys, Enum[] expectedResult) 60object result = converter.ConvertTo(keys, typeof(Enum[])); 68object resultWithoutCulture = converter.ConvertTo(context: null, culture: null, keys, typeof(Enum[])); 69object resultWithUICulture = converter.ConvertTo(context: null, culture: Thread.CurrentThread.CurrentUICulture, keys, typeof(Enum[]));

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

255foreach (ContentAlignment value in Enum.GetValues(typeof(ContentAlignment))) 309foreach (BorderStyle style in Enum.GetValues(typeof(BorderStyle)))

System\Windows\Forms\ListBoxTests.cs (6)

1707foreach (Enum drawMode in Enum.GetValues(typeof(DrawMode))) 3384foreach (SelectionMode selectionMode in Enum.GetValues(typeof(SelectionMode))) 3386foreach (SelectionMode value in Enum.GetValues(typeof(SelectionMode))) 4790foreach (BorderStyle borderStyle in Enum.GetValues(typeof(BorderStyle))) 5157foreach (DrawMode drawMode in Enum.GetValues(typeof(DrawMode)))

System\Windows\Forms\ListViewGroupTests.cs (3)

642foreach (HorizontalAlignment value in Enum.GetValues(typeof(HorizontalAlignment))) 748HorizontalAlignment value = (HorizontalAlignment)Enum.Parse(typeof(HorizontalAlignment), valueString); 1000HorizontalAlignment value = (HorizontalAlignment)Enum.Parse(typeof(HorizontalAlignment), valueString);

System\Windows\Forms\ListViewTests.cs (11)

System\Windows\Forms\MessageBoxTests.cs (3)

30foreach (MessageBoxButtons value in Enum.GetValues(typeof(MessageBoxButtons))) 73foreach (MessageBoxIcon value in Enum.GetValues(typeof(MessageBoxIcon))) 115foreach (MessageBoxDefaultButton value in Enum.GetValues(typeof(MessageBoxDefaultButton)))

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

816foreach (ToolTipIcon tipIcon in Enum.GetValues(typeof(ToolTipIcon)))

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

2487foreach (PictureBoxSizeMode sizeMode in Enum.GetValues(typeof(PictureBoxSizeMode))) 2558foreach (PictureBoxSizeMode sizeMode in Enum.GetValues(typeof(PictureBoxSizeMode)))

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

34var values = Enum.GetValues(typeof(BatteryChargeStatus)) 69Assert.True(Enum.IsDefined(status.PowerLineStatus));

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

35if (Enum.IsDefined(typeof(Keys), e.KeyValue))

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

764foreach (ProgressBarStyle style in Enum.GetValues(typeof(ProgressBarStyle))) 2094foreach (ProgressBarStyle style in Enum.GetValues(typeof(ProgressBarStyle)))

System\Windows\Forms\RadioButtonTests.cs (6)

304foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle))) 306foreach (ContentAlignment value in Enum.GetValues(typeof(ContentAlignment))) 342foreach (ContentAlignment value in Enum.GetValues(typeof(ContentAlignment))) 1048foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle))) 1100foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle))) 1204foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))

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

1817foreach (RichTextBoxLanguageOptions options in Enum.GetValues(typeof(RichTextBoxLanguageOptions))) 2909foreach (RichTextBoxScrollBars value in Enum.GetValues(typeof(RichTextBoxScrollBars)))

System\Windows\Forms\ScrollableControlTests.cs (10)

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

1768foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified))) 1816foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))

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

1169foreach (DockStyle childDock in Enum.GetValues(typeof(DockStyle)))

System\Windows\Forms\StatusStripTests.cs (8)

System\Windows\Forms\SystemInformationTests.cs (3)

43Assert.True(Enum.IsDefined(bootMode)); 614Assert.True(Enum.IsDefined(alignment)); 654Assert.True(Enum.IsDefined(orientation));

System\Windows\Forms\TableLayoutPanel.TableLayoutPanelAccessibleObectTests.cs (1)

50Array roles = Enum.GetValues(typeof(AccessibleRole));

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

1412foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft))) 1414foreach (TableLayoutPanelCellBorderStyle cellBorderStyle in Enum.GetValues(typeof(TableLayoutPanelCellBorderStyle)))

System\Windows\Forms\TabPageTests.cs (9)

System\Windows\Forms\TabRendererTests.cs (6)

37foreach (TabItemState state in Enum.GetValues<TabItemState>()) 53foreach (TabItemState state in Enum.GetValues<TabItemState>()) 68foreach (TabItemState state in Enum.GetValues<TabItemState>()) 83foreach (TabItemState state in Enum.GetValues<TabItemState>()) 99foreach (TabItemState state in Enum.GetValues<TabItemState>()) 117foreach (TabItemState state in Enum.GetValues<TabItemState>())

System\Windows\Forms\TextRendererTests.cs (8)

System\Windows\Forms\ToolStrip.ToolStripAccessibleObjectWrapperForItemsOnOverflowTests.cs (1)

60Array roles = Enum.GetValues(typeof(AccessibleRole));

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

1446foreach (ToolStripItemDisplayStyle displayStyle in Enum.GetValues(typeof(ToolStripItemDisplayStyle)))

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

957foreach (Enum displayStyle in Enum.GetValues(typeof(ToolStripItemDisplayStyle)))

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

4723foreach (ScrollEventType eventType in Enum.GetValues(typeof(ScrollEventType))) 4725foreach (ScrollOrientation orientation in Enum.GetValues(typeof(ScrollOrientation)))

System\Windows\Forms\ToolStripItemTests.cs (6)

2966foreach (Enum displayStyle in Enum.GetValues(typeof(ToolStripItemDisplayStyle))) 2992foreach (Enum displayStyle in Enum.GetValues(typeof(ToolStripItemDisplayStyle))) 10150foreach (DragDropEffects allowedEffects in Enum.GetValues(typeof(DragDropEffects))) 11325foreach (ToolStripItemDisplayStyle displayStyle in Enum.GetValues(typeof(ToolStripItemDisplayStyle)))

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

30foreach (ArrowDirection arrowDirection in Enum.GetValues(typeof(ArrowDirection))) 198foreach (ToolStripItemImageScaling imageScaling in Enum.GetValues(typeof(ToolStripItemImageScaling)))

System\Windows\Forms\ToolStripSeparatorTests.cs (8)

311foreach (Enum displayStyle in Enum.GetValues(typeof(ToolStripItemDisplayStyle))) 818foreach (ToolStripLayoutStyle layoutStyle in Enum.GetValues(typeof(ToolStripLayoutStyle))) 917foreach (ToolStripItemDisplayStyle displayStyle in Enum.GetValues(typeof(ToolStripItemDisplayStyle))) 1115foreach (ToolStripLayoutStyle layoutStyle in Enum.GetValues(typeof(ToolStripLayoutStyle))) 1199foreach (ToolStripLayoutStyle ownerLayoutStyle in Enum.GetValues(typeof(ToolStripLayoutStyle))) 1271foreach (ToolStripLayoutStyle ownerLayoutStyle in Enum.GetValues(typeof(ToolStripLayoutStyle))) 1273foreach (ToolStripLayoutStyle parentLayoutStyle in Enum.GetValues(typeof(ToolStripLayoutStyle)))

System\Windows\Forms\ToolStripTests.cs (11)

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

12foreach (TreeViewHitTestLocations hitLocation in Enum.GetValues(typeof(TreeViewHitTestLocations)))

System\Windows\Forms\UpDownBaseTests.cs (18)

TextBoxBaseTests.cs (2)

6450foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified))) 6581foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))

TrackBarTests.cs (6)

1967foreach (Orientation orientation in Enum.GetValues(typeof(Orientation))) 1969foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft))) 2838foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified))) 2840foreach (Orientation orientation in Enum.GetValues(typeof(Orientation))) 2855foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified))) 2888foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))

TrackBarTestHelper.cs (8)

Infra\ControlTestBase.cs (1)

113foreach (var code in Enum.GetValues<VIRTUAL_KEY>())

System\Windows\Markup\StaticExtension.cs (1)

101return Enum.Parse(type, fieldString);

src\Compilers\Core\Portable\InternalUtilities\EnumUtilties.cs (3)

16return (T[])Enum.GetValues(typeof(T)); 20internal static bool ContainsAllValues<T>(int mask) where T : struct, Enum, IConvertible 33internal static bool ContainsValue<T>(T value) where T : struct, Enum

src\Dependencies\Contracts\EnumExtensions.cs (4)

12public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 13=> Enum.GetValues<TEnum>(); 15public static string[] GetNames<TEnum>() where TEnum : struct, Enum 16=> Enum.GetNames<TEnum>();

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

181&& Enum.GetUnderlyingType(typeof(TValue)).GetTypeInfo().IsAssignableFrom(Enum.GetUnderlyingType(resultType).GetTypeInfo()))

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (3)

29ImmutableHashSet.CreateRange(Enum.GetValues<OutputKind>()); 146tryParseValue: static (value, out result) => Enum.TryParse(value, ignoreCase: true, result: out result), 166if (Enum.TryParse(kindStr, ignoreCase: true, result: out TEnum kind))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\CodeStyle\CodeStyleOption2`1.cs (1)

188var severity = (DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), severityAttribute.Value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (1)

480capitalizationScheme: (Capitalization)Enum.Parse(typeof(Capitalization), namingStyleElement.Attribute(nameof(CapitalizationScheme)).Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SerializableNamingRule.cs (1)

38EnforcementLevel = ((DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), namingRuleElement.Attribute(nameof(EnforcementLevel))!.Value)).ToReportDiagnostic(),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (5)

310=> (Accessibility)Enum.Parse(typeof(Accessibility), accessibilityElement.Value); 421var symbolKind = (SymbolKind)Enum.Parse(typeof(SymbolKind), symbolKindElement.Value); 433=> new((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value)); 436=> new((MethodKind)Enum.Parse(typeof(MethodKind), methodKindElement.Value)); 536=> new((ModifierKindEnum)Enum.Parse(typeof(ModifierKindEnum), modifierElement.Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (9)

104public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>() where T : struct, Enum 112public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map) where T : struct, Enum 119public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map, ImmutableDictionary<string, T> alternative) where T : struct, Enum 127public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(IEnumerable<(string name, T value)> entries, IEnumerable<(string name, T value)> alternativeEntries) where T : struct, Enum 136public static EditorConfigValueSerializer<T?> CreateSerializerForNullableEnum<T>() where T : struct, Enum 158private static bool TryParseEnum<T>(string str, out T result) where T : struct, Enum 173return Enum.TryParse(str, ignoreCase: true, out result); 209where TFromEnum : struct, Enum 210where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (1)

27=> (SpecialType)Enum.Parse(typeof(SpecialType), arg);

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

144where TFromEnum : struct, Enum 145where TToEnum : struct, Enum

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

17where TFromEnum : struct, Enum 18where TToEnum : struct, Enum

tests\testproject\Common\TestResourceNames.cs (2)

24if (Enum.TryParse<TestResourceNames>(resourceName, ignoreCase: true, out var name)) 39return string.Join(',', Enum.GetValues<TestResourceNames>()

tests\testproject\Common\TestResourceNames.cs (2)

24if (Enum.TryParse<TestResourceNames>(resourceName, ignoreCase: true, out var name)) 39return string.Join(',', Enum.GetValues<TestResourceNames>()

src\Compilers\Core\Portable\InternalUtilities\EnumUtilties.cs (3)

16return (T[])Enum.GetValues(typeof(T)); 20internal static bool ContainsAllValues<T>(int mask) where T : struct, Enum, IConvertible 33internal static bool ContainsValue<T>(T value) where T : struct, Enum

src\Dependencies\Contracts\EnumExtensions.cs (5)

18extension(Enum) 20public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum 21=> (TEnum[])Enum.GetValues(typeof(TEnum)); 23public static string[] GetNames<TEnum>() where TEnum : struct, Enum 24=> Enum.GetNames(typeof(TEnum));

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (2)

181&& Enum.GetUnderlyingType(typeof(TValue)).GetTypeInfo().IsAssignableFrom(Enum.GetUnderlyingType(resultType).GetTypeInfo()))

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (3)

29ImmutableHashSet.CreateRange(Enum.GetValues<OutputKind>()); 146tryParseValue: static (value, out result) => Enum.TryParse(value, ignoreCase: true, result: out result), 166if (Enum.TryParse(kindStr, ignoreCase: true, result: out TEnum kind))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\CodeStyle\CodeStyleOption2`1.cs (1)

188var severity = (DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), severityAttribute.Value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.cs (1)

480capitalizationScheme: (Capitalization)Enum.Parse(typeof(Capitalization), namingStyleElement.Attribute(nameof(CapitalizationScheme)).Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SerializableNamingRule.cs (1)

38EnforcementLevel = ((DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), namingRuleElement.Attribute(nameof(EnforcementLevel))!.Value)).ToReportDiagnostic(),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (5)

310=> (Accessibility)Enum.Parse(typeof(Accessibility), accessibilityElement.Value); 421var symbolKind = (SymbolKind)Enum.Parse(typeof(SymbolKind), symbolKindElement.Value); 433=> new((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value)); 436=> new((MethodKind)Enum.Parse(typeof(MethodKind), methodKindElement.Value)); 536=> new((ModifierKindEnum)Enum.Parse(typeof(ModifierKindEnum), modifierElement.Value));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (9)

104public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>() where T : struct, Enum 112public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map) where T : struct, Enum 119public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map, ImmutableDictionary<string, T> alternative) where T : struct, Enum 127public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(IEnumerable<(string name, T value)> entries, IEnumerable<(string name, T value)> alternativeEntries) where T : struct, Enum 136public static EditorConfigValueSerializer<T?> CreateSerializerForNullableEnum<T>() where T : struct, Enum 158private static bool TryParseEnum<T>(string str, out T result) where T : struct, Enum 173return Enum.TryParse(str, ignoreCase: true, out result); 209where TFromEnum : struct, Enum 210where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SpecialTypeAnnotation.cs (1)

27=> (SpecialType)Enum.Parse(typeof(SpecialType), arg);

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

144where TFromEnum : struct, Enum 145where TToEnum : struct, Enum

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

17where TFromEnum : struct, Enum 18where TToEnum : struct, Enum

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.AbstractTypeInferrer.cs (1)

119symbol.Name == nameof(Enum.HasFlag) &&

System\Windows\Automation\Text\TextRange.cs (1)

244obj = Enum.ToObject(ai.Type, (int)obj);

MS\Internal\AutomationProxies\WindowsEditBoxRange.cs (1)

185if (targetAttribute is Enum)

MS\Internal\AutomationProxies\WindowsRichEditRange.cs (1)

436else if (v2 is Enum)

Scenarios\GridScenario.cs (1)

23? (GridRendering.GridRenderMode)Enum.Parse(typeof(GridRendering.GridRenderMode), _gridTypeOption.Value(), true)

System\Diagnostics\PresentationTraceSourcesTests.cs (12)

System\Windows\BaseCompatibilityPreferencesTests.cs (1)

19Assert.True(Enum.IsDefined(value));

MainForm.cs (1)

23Array mainFormControlsTabOrderItems = Enum.GetValues(typeof(MainFormControlsTabOrder));

CommandLine.cs (1)

370if (!Enum.TryParse(option.Value, out ParallelismOption parallelismOption))