StringComparison

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\ParameterValidationAnalysis\ParameterValidationAnalysis.ParameterValidationDataFlowOperationVisitor.cs (1)

126(attr.AttributeClass.Name.Equals("ValidatedNotNullAttribute", StringComparison.OrdinalIgnoreCase) ||

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PointsToAnalysis\PointsToAnalysis.PointsToDataFlowOperationVisitor.cs (3)

981!method.Name.StartsWith("Create", StringComparison.Ordinal) || 990if (method.Name.Equals("CreateInstance", StringComparison.Ordinal) && 1017symbol.Name.Equals("Empty", StringComparison.Ordinal) &&

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

94if ((!typeSymbol.GetBaseTypesAndThis().Any(x => x.Name.EndsWith("Controller", System.StringComparison.Ordinal))

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\ValueContentAnalysis\ValueContentAnalysis.ValueContentDataFlowOperationVisitor.cs (1)

261if (operation.Field.Name.Equals("Empty", StringComparison.Ordinal) &&

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\DataFlowOperationVisitor.cs (1)

3230(targetMethod.Name.EndsWith("Equals", StringComparison.Ordinal) ||

RestrictedInternalsVisibleToAnalyzer.cs (1)

153!string.Equals(assemblyName, compilation.Assembly.Name, StringComparison.OrdinalIgnoreCase))

src\RoslynAnalyzers\Utilities\Compiler\AdditionalFileProvider.cs (1)

43=> _additionalFiles.FirstOrDefault(x => Path.GetFileName(x.Path).Equals(fileName, StringComparison.OrdinalIgnoreCase));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

142var index = symbolName.LastIndexOf(".", StringComparison.OrdinalIgnoreCase);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\CompilationExtensions.cs (3)

35if (string.Equals(propertyValue?.Trim(), "true", StringComparison.OrdinalIgnoreCase)) 42(propertyValue.Contains(WebAppProjectGuidString, StringComparison.OrdinalIgnoreCase) || 43propertyValue.Contains(WebSiteProjectGuidString, StringComparison.OrdinalIgnoreCase)))

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (8)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IPropertySymbolExtensions.cs (1)

28|| !property.Name.Equals("IsCompleted", StringComparison.Ordinal)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (1)

840=> symbol?.Name.StartsWith("_", StringComparison.Ordinal) == true &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\StringExtensions.cs (1)

24return str.EndsWith(suffix, StringComparison.Ordinal);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\UriExtensions.cs (1)

38if (symbol.Name.Contains(word, StringComparison.OrdinalIgnoreCase))

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

403if (!genericInterfaceFullName.StartsWith("T:", StringComparison.Ordinal)) 478(optionValue == null || !optionValue.Contains(arg.optionForcedValue, StringComparison.Ordinal))) 505(optionValue == null || !optionValue.Contains(optionForcedValue, StringComparison.Ordinal)))

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (12)

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (2)

166if (xtext.Value.Contains("\r", StringComparison.Ordinal) || xtext.Value.Contains("\n", StringComparison.Ordinal))

src\RoslynAnalyzers\Utilities\Compiler\WordParser.cs (1)

250if (string.Equals(parsedWord, word, StringComparison.OrdinalIgnoreCase))

SymbolIsBannedAnalyzer.cs (3)

61where fileName != null && fileName.StartsWith("BannedSymbols.", StringComparison.Ordinal) && fileName.EndsWith(".txt", StringComparison.Ordinal) 67let commentIndex = text.IndexOf("//", StringComparison.Ordinal)

SymbolIsBannedAnalyzerBase.cs (2)

193if (!kvp.Key.SymbolName.EndsWith("Attribute", StringComparison.InvariantCulture) && 194!kvp.Key.ContainerName.EndsWith("Attribute", StringComparison.InvariantCulture))

src\Analyzers\Core\Analyzers\Helpers\DiagnosticHelper.cs (2)

327if (id.StartsWith("JSON", StringComparison.Ordinal)) 337Debug.Assert(id.StartsWith("IDE", StringComparison.Ordinal));

src\Analyzers\Core\Analyzers\MatchFolderAndNamespace\AbstractMatchFolderAndNamespaceDiagnosticAnalyzer.cs (1)

155if (RoslynString.IsNullOrWhiteSpace(expectedNamespace) || expectedNamespace.Equals(currentNamespace, StringComparison.OrdinalIgnoreCase))

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

375if (trimmedPart.StartsWith(categoryPrefix, StringComparison.OrdinalIgnoreCase))

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

473static (field, property) => field.Name.EndsWith(property.Name, StringComparison.OrdinalIgnoreCase),

src\Compilers\Core\Portable\DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (1)

52if (id != null && prefix != null && id.StartsWith(prefix, StringComparison.Ordinal))

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (1)

221if (path.IndexOf("://", StringComparison.Ordinal) >= 0 || path.IndexOfAny(s_invalidPathChars) >= 0)

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (8)

163internal static bool IsSameDirectoryOrChildOf(string child, string parent, StringComparison comparison = StringComparison.OrdinalIgnoreCase) 498return string.Equals(extension, ".dll", StringComparison.OrdinalIgnoreCase) 499|| string.Equals(extension, ".exe", StringComparison.OrdinalIgnoreCase) 517var comparison = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal; 718if (filePath.StartsWith(oldPrefix, StringComparison.Ordinal))

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

54return string.Equals(name1, name2, fromVb ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase); 59return string.Equals(name1, name2, StringComparison.Ordinal);

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

175var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;

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

751=> text.Equals(array.AsSpan(), StringComparison.Ordinal);

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (5)

66if (fileName.StartsWith("TemporaryGeneratedFile_", StringComparison.OrdinalIgnoreCase)) 75if (fileNameWithoutExtension.EndsWith(".designer", StringComparison.OrdinalIgnoreCase) || 76fileNameWithoutExtension.EndsWith(".generated", StringComparison.OrdinalIgnoreCase) || 77fileNameWithoutExtension.EndsWith(".g", StringComparison.OrdinalIgnoreCase) || 78fileNameWithoutExtension.EndsWith(".g.i", StringComparison.OrdinalIgnoreCase))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\Section.cs (1)

20private bool IsSplatHeader => Text.Equals("*", StringComparison.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (2)

145if (startDelimiter.Length > 0 && !tokenText.StartsWith(startDelimiter, StringComparison.Ordinal)) 151if (endDelimiter.Length > 0 && !tokenText.EndsWith(endDelimiter, StringComparison.Ordinal))

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

97where kvp.Key.Trim().StartsWith("dotnet_naming_rule.", StringComparison.Ordinal)

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

47if (str.Equals("null", StringComparison.InvariantCultureIgnoreCase)) 78=> new(parseValue: str => str.Equals(emptyStringRepresentation, StringComparison.Ordinal) ? default(Optional<string>) : EscapeLineBreaks(str), 143if (str.Equals("null", StringComparison.InvariantCultureIgnoreCase))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\Option2.cs (3)

69Debug.Assert(LanguageName is null == (Definition.ConfigName.StartsWith(OptionDefinition.LanguageAgnosticConfigNamePrefix, StringComparison.Ordinal) || 71Debug.Assert(LanguageName is LanguageNames.CSharp == Definition.ConfigName.StartsWith(OptionDefinition.CSharpConfigNamePrefix, StringComparison.Ordinal)); 72Debug.Assert(LanguageName is LanguageNames.VisualBasic == Definition.ConfigName.StartsWith(OptionDefinition.VisualBasicConfigNamePrefix, StringComparison.Ordinal));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\PerLanguageOption2.cs (2)

60Debug.Assert(!Definition.ConfigName.StartsWith(OptionDefinition.CSharpConfigNamePrefix, StringComparison.Ordinal)); 61Debug.Assert(!Definition.ConfigName.StartsWith(OptionDefinition.VisualBasicConfigNamePrefix, StringComparison.Ordinal));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.cs (5)

271=> string.Equals(name1, name2, isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase); 365var comparison = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

66if (rootNamespace is not null && @namespace.StartsWith(rootNamespace + ".", StringComparison.OrdinalIgnoreCase))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SignatureComparer.cs (1)

103: string.Equals(identifier1, identifier2, StringComparison.OrdinalIgnoreCase);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (1)

39: string.Equals(x.Name, y.Name, StringComparison.OrdinalIgnoreCase);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\WordSimilarityChecker.cs (1)

124if (_substringsAreSimilar && candidateText.IndexOf(_source, StringComparison.OrdinalIgnoreCase) >= 0)

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (1)

269: string.Equals(ctorParameter.Name, parameterName, StringComparison.OrdinalIgnoreCase);

src\Analyzers\Core\CodeFixes\GenerateConstructor\GenerateConstructorHelpers.cs (2)

274where m.Name.Equals(memberName, StringComparison.OrdinalIgnoreCase) 280return membersArray.FirstOrDefault(m => m.Name.Equals(memberName, StringComparison.Ordinal)) ?? membersArray.FirstOrDefault();

Binder\Binder.WithQueryLambdaParametersBinder.cs (1)

56Debug.Assert(base.lambdaSymbol.Parameters[0].Name.StartsWith(transparentIdentifierPrefix, StringComparison.Ordinal));

Binder\Binder_Expressions.cs (3)

7342if (text.EndsWith("l", StringComparison.Ordinal)) 7348else if (text.EndsWith("lu", StringComparison.Ordinal) || text.EndsWith("lU", StringComparison.Ordinal))

CommandLine\CSharpCommandLineParser.cs (5)

166Debug.Assert(optionsEnded || !arg.StartsWith("@", StringComparison.Ordinal)); 210else if (value.StartsWith("0", StringComparison.Ordinal)) 2056else if (string.Equals(accessibility, "public", StringComparison.OrdinalIgnoreCase)) 2060else if (string.Equals(accessibility, "private", StringComparison.OrdinalIgnoreCase)) 2101if (part.Span.Equals(nullableSpan, StringComparison.OrdinalIgnoreCase))

Compiler\DocumentationCommentCompiler.cs (4)

500&& string.Equals(nameAttribute.Identifier.Identifier.ValueText, propertyName, StringComparison.Ordinal)) 997Debug.Assert(pattern.StartsWith(currentLinePattern, StringComparison.Ordinal)); 1042int index = trimmed.IndexOf("*/", StringComparison.Ordinal); 1391int position = message.IndexOf(locationString, StringComparison.Ordinal); // Expect exact match

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)

276int colonColonIndex = metadataName.IndexOf("::", StringComparison.Ordinal);

Emitter\EditAndContinue\CSharpDefinitionMap.cs (1)

223hasDebugIds = !isDisplayClassParentField && name.AsSpan(suffixIndex).StartsWith(GeneratedNameConstants.SuffixSeparator.AsSpan(), StringComparison.Ordinal);

Emitter\Model\PEModuleBuilder.cs (1)

179!string.Equals(refIdentity.CultureName, asmIdentity.CultureName, StringComparison.OrdinalIgnoreCase))

Parser\DirectiveParser.cs (2)

333if (errorText.Equals("version", StringComparison.Ordinal)) 348errorText.StartsWith(versionMarker, StringComparison.Ordinal) &&

Parser\Lexer.cs (1)

1624Debug.Assert(string.Equals(info.Text.Substring(0, objectAddressOffset + 1), "@0x", StringComparison.OrdinalIgnoreCase));

Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (1)

515if (moduleId.EndsWith(extension, StringComparison.OrdinalIgnoreCase))

Symbols\Attributes\SourceAttributeData.cs (1)

300if (!string.Equals(namedType.MetadataName, targetInfo.Name, System.StringComparison.Ordinal) ||

Symbols\Extensions\SourceExtensionImplementationMethodSymbol.cs (1)

144Debug.Assert(string.Equals(result, withIncludes, System.StringComparison.Ordinal));

Symbols\FunctionPointers\FunctionPointerTypeSymbol.cs (1)

213&& modifierType.Name.StartsWith("CallConv", StringComparison.Ordinal)

Symbols\Metadata\PE\MetadataDecoder.cs (1)

159if (string.Equals(m.Name, moduleName, StringComparison.OrdinalIgnoreCase))

Symbols\Metadata\PE\PEMethodSymbol.cs (1)

1188if (_name.StartsWith(".", StringComparison.Ordinal))

Symbols\Metadata\PE\PEParameterSymbol.cs (2)

765if (parameters[i].Name.Equals(parameterName, StringComparison.Ordinal)) 895var param = parameters.FirstOrDefault(static (p, name) => string.Equals(p.Name, name, StringComparison.Ordinal), name);

Symbols\MissingMetadataTypeSymbol.cs (3)

394return string.Equals(MetadataName, other.MetadataName, StringComparison.Ordinal) && 396string.Equals(_namespaceName, other.NamespaceName, StringComparison.Ordinal) && 463return (object?)other != null && string.Equals(MetadataName, other.MetadataName, StringComparison.Ordinal) &&

Symbols\MissingModuleSymbol.cs (1)

241return (object)other != null && assembly.Equals(other.assembly, compareKind) && string.Equals(_name, other._name, StringComparison.OrdinalIgnoreCase);

Symbols\Source\SourceAssemblySymbol.cs (3)

800else if (String.Compare(_compilation.Options.CryptoKeyContainer, assemblyKeyContainerAttributeSetting, StringComparison.OrdinalIgnoreCase) != 0) 847else if (String.Compare(_compilation.Options.CryptoKeyFile, assemblyKeyFileAttributeSetting, StringComparison.OrdinalIgnoreCase) != 0) 979if (!string.Equals(fileName, moduleName, StringComparison.OrdinalIgnoreCase))

Symbols\Source\SourceComplexParameterSymbol.cs (2)

683if (parameters[i].Name.Equals(parameterName, StringComparison.Ordinal)) 1351var parameter = containingSymbolParameters.FirstOrDefault(static (param, name) => string.Equals(param.Name, name, StringComparison.Ordinal), name);

Symbols\Synthesized\GeneratedNameParser.cs (7)

17=> name.StartsWith(GeneratedNameConstants.SynthesizedLocalNamePrefix, StringComparison.Ordinal); 35if (name.StartsWith("CS$<", StringComparison.Ordinal)) 39else if (name.StartsWith("<", StringComparison.Ordinal)) 166if (typeParameterName.StartsWith("<", StringComparison.Ordinal) && 167typeParameterName.EndsWith(">j__TPar", StringComparison.Ordinal)) 181if (fieldName.StartsWith("<", StringComparison.Ordinal) && 182fieldName.EndsWith(">P", StringComparison.Ordinal))

Symbols\Synthesized\SynthesizedIntrinsicOperatorSymbol.cs (1)

438string.Equals(_name, other._name, StringComparison.Ordinal) &&

Symbols\Tuples\TupleTypeSymbol.cs (2)

468if (name.StartsWith("Item", StringComparison.Ordinal)) 473if (number > 0 && string.Equals(name, TupleMemberName(number), StringComparison.Ordinal))

Symbols\TypeSymbolExtensions.cs (3)

1775const StringComparison comparison = StringComparison.Ordinal; 1793private static bool HasNamespaceName(NamespaceSymbol @namespace, string namespaceName, StringComparison comparison, int length)

Symbols\UnboundGenericType.cs (1)

113return (object?)other != null && string.Equals(other._name, _name, StringComparison.Ordinal) && object.Equals(other._errorInfo, _errorInfo);

Syntax\SyntaxFactory.cs (3)

323if (text.StartsWith("@", StringComparison.Ordinal)) 1206if (rewrittenToken.IsKind(SyntaxKind.LessThanToken) && string.Equals("<", rewrittenToken.Text, StringComparison.Ordinal)) 1209if (rewrittenToken.IsKind(SyntaxKind.GreaterThanToken) && string.Equals(">", rewrittenToken.Text, StringComparison.Ordinal))

src\Analyzers\CSharp\Analyzers\FileHeaders\CSharpFileHeaderHelper.cs (2)

30var startIndex = triviaString.IndexOf("/*", StringComparison.Ordinal) + 2; 31var endIndex = triviaString.LastIndexOf("*/", StringComparison.Ordinal);

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

173if (expressionType is null || expressionType.Name.EndsWith("Builder", StringComparison.Ordinal)) 429if (!name.StartsWith(ToPrefix, StringComparison.Ordinal)) 440name.EndsWith(suffix, StringComparison.Ordinal))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\CodeStyle\TypeStyle\TypeStyleHelper.cs (1)

179return methodSymbol.Name.Equals("To" + returnTypeName, StringComparison.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\EmbeddedLanguages\VirtualChars\CSharpVirtualCharService.cs (1)

240if (endDelimiter.Length > 0 && !tokenText.EndsWith(endDelimiter, StringComparison.OrdinalIgnoreCase))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxTriviaExtensions.cs (4)

68if (commentText.StartsWith("//", StringComparison.Ordinal)) 79if (commentText.EndsWith("*/", StringComparison.Ordinal)) 84if (commentText.StartsWith("/*", StringComparison.Ordinal)) 99if (trimmedLine.StartsWith("*", StringComparison.Ordinal))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\FormattingHelpers.cs (2)

26var lastNewLinePos = indent.LastIndexOf(NewLine, StringComparison.Ordinal); 39var lastNewLinePos = leading.LastIndexOf(NewLine, StringComparison.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\CSharpCodeGenerationHelpers.cs (1)

98if (!text.EndsWith(MultiLineCommentTerminator, StringComparison.Ordinal))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\CSharpDeclarationComparer.cs (1)

397comparisonResult = string.Compare(x.ValueText, y.ValueText, StringComparison.OrdinalIgnoreCase);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\EnumMemberGenerator.cs (2)

143if (numericText.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) 149else if (numericText.StartsWith("0b", StringComparison.OrdinalIgnoreCase))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\DocumentationCommentExtensions.cs (1)

20return documentationComment.ToFullString().StartsWith("/**", StringComparison.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\StringExtensions.cs (2)

42var unescaped = identifier.StartsWith("@", StringComparison.Ordinal) 49if (!identifier.StartsWith("@", StringComparison.Ordinal))

CommandLineTests.cs (302)

StringCopyPaste\UnknownSourcePasteProcessor.cs (2)

191if (fullChangeLineText.StartsWith(commonIndentationPrefix, StringComparison.OrdinalIgnoreCase)) 287if (commonIndentationPrefix != null && lineLeadingWhitespace.StartsWith(commonIndentationPrefix, StringComparison.OrdinalIgnoreCase))

Classification\SemanticClassifierTests_TestMarkup.cs (4)

50var start = allCode.IndexOf(code, StringComparison.Ordinal); 71var start = allCode.IndexOf(code, StringComparison.Ordinal); 141new TextSpan(allCode.IndexOf(code1, StringComparison.Ordinal), code1.Length), 142new TextSpan(allCode.IndexOf(code2, StringComparison.Ordinal), code2.Length)

CodeActions\PreviewTests.cs (2)

129Assert.Contains(s_removedMetadataReferenceDisplayName, text, StringComparison.Ordinal); 136Assert.Contains(AddedProjectName, text, StringComparison.Ordinal);

Completion\CompletionProviders\SnippetCompletionProviderTests.cs (2)

158=> string.Equals(shortcut, SnippetShortcut, StringComparison.OrdinalIgnoreCase) || 159string.Equals(shortcut, PreProcessorSnippetShortcut, StringComparison.OrdinalIgnoreCase);

CodeGen\CodeGenAsyncLocalsTests.cs (2)

964var stateMachineClass = (NamedTypeSymbol)testClass.GetMembers().Single(s => s.Name.StartsWith("<Run>", StringComparison.Ordinal)); 965IEnumerable<IGrouping<TypeSymbol, FieldSymbol>> spillFieldsByType = stateMachineClass.GetMembers().Where(m => m.Kind == SymbolKind.Field && m.Name.StartsWith("<>7__wrap", StringComparison.Ordinal)).Cast<FieldSymbol>().GroupBy(x => x.Type);

CodeGen\CodeGenDynamicTests.cs (1)

137foreach (var src in excludeBinder == null ? _binderFactoriesSource : _binderFactoriesSource.Where(src => src.IndexOf(excludeBinder, StringComparison.Ordinal) == -1))

CodeGen\CodeGenExplicitImplementationTests.cs (2)

1003AssertEx.All(classCMembers.Select(m => m.Name), name => name == WellKnownMemberNames.InstanceConstructorName || name.StartsWith("Q::I.", StringComparison.Ordinal)); 1004AssertEx.All(classCMembers.Select(m => m.MetadataName), metadataName => metadataName == WellKnownMemberNames.InstanceConstructorName || metadataName.StartsWith("Q::I.", StringComparison.Ordinal));

CodeGen\CodeGenIterators.cs (3)

1946Assert.Contains("System.Environment.CurrentManagedThreadId.get", il, StringComparison.Ordinal); 1979Assert.Contains("System.Environment.CurrentManagedThreadId.get", il, StringComparison.Ordinal); 2330Assert.True(expectedIL.IndexOf("<>_", StringComparison.Ordinal) < 0);

CodeGen\SwitchTests.cs (1)

3042var pid = ((NamedTypeSymbol)comp.GlobalNamespace.GetMembers().Single(s => s.Name.StartsWith("<PrivateImplementationDetails>", StringComparison.Ordinal)));

Emit\CompilationEmitTests.cs (1)

626if (name.Equals(".mvid", StringComparison.Ordinal))

Emit\EditAndContinue\LocalSlotMappingTests.cs (1)

2006Assert.True(source.IndexOf(tooManyCommas, StringComparison.Ordinal) > 0);

Attributes\AttributeTests.cs (1)

5719int index = main.IndexOf("M()", StringComparison.Ordinal);

Attributes\AttributeTests_Assembly.cs (2)

1023.Where(a => string.Equals(a.AttributeClass.Name, attrTypeName, StringComparison.Ordinal)); 1036.Where(a => string.Equals(a.AttributeClass.Name, attrTypeName, StringComparison.Ordinal));

Attributes\AttributeTests_Dynamic.cs (1)

521var synthesizedDynamicAttributes = attributes.Where((attr) => string.Equals(attr.AttributeClass.Name, "DynamicAttribute", StringComparison.Ordinal));

Attributes\AttributeTests_Synthesized.cs (1)

127var pid = (NamedTypeSymbol)comp.GlobalNamespace.GetMembers().Where(s => s.Name.StartsWith("<PrivateImplementationDetails>", StringComparison.Ordinal)).Single();

Attributes\AttributeTests_Tuples.cs (1)

618var synthesizedTupleElementNamesAttr = attributes.Where(attr => string.Equals(attr.AttributeClass.Name, "TupleElementNamesAttribute", StringComparison.Ordinal));

Attributes\AttributeTests_WellKnownAttributes.cs (4)

49if (name.AsSpan().Equals(typeName, StringComparison.Ordinal)) 65if (name.AsSpan().Equals(methodName, StringComparison.Ordinal)) 3560name.StartsWith("__StaticArrayInitTypeSize=", StringComparison.Ordinal) || 3561name.StartsWith("<PrivateImplementationDetails>", StringComparison.Ordinal))

Attributes\InternalsVisibleToAndStrongNameTests.cs (2)

404Assert.True(((string)err.Arguments[1]).EndsWith("0x80090016)", StringComparison.Ordinal), (string)err.Arguments[1]); 1616Assert.True(((string)err.Arguments[1]).EndsWith("0x80090016)", StringComparison.Ordinal), (string)err.Arguments[1]);

Diagnostics\DiagnosticAnalyzerTests.cs (1)

56if (id.Identifier.ValueText.StartsWith("x", StringComparison.Ordinal))

FlowAnalysis\FlowTestBase.cs (8)

FlowAnalysis\RegionAnalysisTests.cs (6)

4426var index = tree.GetCompilationUnitRoot().ToFullString().IndexOf(".Class)", StringComparison.Ordinal); 6315var statement = GetFirstNode<StatementSyntax>(tree, root.ToFullString().IndexOf("S<object> o", StringComparison.Ordinal)); 6354var statement = GetLastNode<StatementSyntax>(tree, root.ToFullString().IndexOf("if", StringComparison.Ordinal)); 6381var statement = GetLastNode<StatementSyntax>(tree, root.ToFullString().IndexOf("EditorOperations", StringComparison.Ordinal)); 6447var statement = GetFirstNode<StatementSyntax>(tree, root.ToFullString().IndexOf("P = new object()", StringComparison.Ordinal)); 6482var expression = GetLastNode<ExpressionSyntax>(tree, root.ToFullString().IndexOf("value ", StringComparison.Ordinal));

src\Compilers\CSharp\Portable\Symbols\Synthesized\GeneratedNameParser.cs (7)

17=> name.StartsWith(GeneratedNameConstants.SynthesizedLocalNamePrefix, StringComparison.Ordinal); 35if (name.StartsWith("CS$<", StringComparison.Ordinal)) 39else if (name.StartsWith("<", StringComparison.Ordinal)) 166if (typeParameterName.StartsWith("<", StringComparison.Ordinal) && 167typeParameterName.EndsWith(">j__TPar", StringComparison.Ordinal)) 181if (fieldName.StartsWith("<", StringComparison.Ordinal) && 182fieldName.EndsWith(">P", StringComparison.Ordinal))

ChangeSignature\CSharpChangeSignatureService.cs (1)

833var nameAttribute = paramNode.StartTag.Attributes.FirstOrDefault(a => a.Name.ToString().Equals("name", StringComparison.OrdinalIgnoreCase));

Completion\CompletionProviders\AttributeNamedParameterCompletionProvider.cs (3)

257if (ch == ' ' && displayText.EndsWith(SpaceEqualsString, StringComparison.Ordinal)) 264if (ch == '=' && displayText.EndsWith(EqualsString, StringComparison.Ordinal)) 271if (ch == ':' && displayText.EndsWith(ColonString, StringComparison.Ordinal))

Completion\CompletionProviders\SnippetCompletionProvider.cs (1)

182snippets = snippets.Where(snippet => snippet.Shortcut != null && snippet.Shortcut.StartsWith("#", StringComparison.Ordinal));

Diagnostics\Analyzers\TypeSyntaxSimplifierWalker.cs (1)

204var canTrySimplify = node.Identifier.ValueText.EndsWith("Attribute", StringComparison.Ordinal);

src\Analyzers\CSharp\Analyzers\FileHeaders\CSharpFileHeaderHelper.cs (2)

30var startIndex = triviaString.IndexOf("/*", StringComparison.Ordinal) + 2; 31var endIndex = triviaString.LastIndexOf("*/", StringComparison.Ordinal);

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

173if (expressionType is null || expressionType.Name.EndsWith("Builder", StringComparison.Ordinal)) 429if (!name.StartsWith(ToPrefix, StringComparison.Ordinal)) 440name.EndsWith(suffix, StringComparison.Ordinal))

TaskList\CSharpTaskListService.cs (2)

39var index = message.IndexOf(SingleLineCommentPrefix, StringComparison.Ordinal); 85SyntaxFacts.IsPreprocessorDirective(trivia.Kind()) && trivia.ToString().IndexOf(SingleLineCommentPrefix, StringComparison.Ordinal) > 0;

Diagnostics\Suppression\SuppressionAllCodeTests.cs (2)

36=> await TestPragmaAsync(TestResource.AllInOneCSharpCode, CSharpParseOptions.Default, verifier: t => t.IndexOf("#pragma warning disable", StringComparison.Ordinal) >= 0); 45verifier: t => t.IndexOf("SuppressMessage", StringComparison.Ordinal) >= 0);

EditAndContinue\CSharpEditAndContinueAnalyzerTests.cs (3)

79var start = source.IndexOf(StartTag, i, StringComparison.Ordinal); 86var end = source.IndexOf(EndTag, start + 1, StringComparison.Ordinal); 314var oldStatementPosition = source1.IndexOf(oldStatementSource, StringComparison.Ordinal);

CsiTests.cs (1)

97Assert.True(result.Errors.StartsWith("error CS0006", StringComparison.Ordinal));

InteractiveSessionReferencesTests.cs (1)

468if (args.Name.StartsWith("b,", StringComparison.Ordinal))

Semantics\InteractiveSemanticModelTests.cs (4)

304if (exprFullText.StartsWith("/*<bind>*/", StringComparison.Ordinal)) 308if (exprFullText.EndsWith("/*</bind>*/", StringComparison.Ordinal)) 323if (exprFullText.EndsWith("/*</bind>*/", StringComparison.Ordinal)) 327if (exprFullText.StartsWith("/*<bind>*/", StringComparison.Ordinal))

Semantics\LocalFunctionTests.cs (12)

Semantics\LookupPositionTests.cs (2)

2273var symbols = model.LookupLabels(source.ToString().IndexOf("label1;", StringComparison.Ordinal)); 2301var symbols = model.LookupLabels(source.ToString().IndexOf("HERE", StringComparison.Ordinal));

Semantics\LookupTests.cs (5)

583var position = testSrc.IndexOf("return", StringComparison.Ordinal); 1732int position = source.IndexOf("return", StringComparison.Ordinal); 1759int position = source.IndexOf("return", StringComparison.Ordinal); 1790int position = source.IndexOf("return", StringComparison.Ordinal); 1822int position = source.IndexOf("return", StringComparison.Ordinal);

Semantics\OperatorTests.cs (1)

3214.Select(x => x.Substring(x.IndexOf("//-", StringComparison.Ordinal) + 3).Trim())

Semantics\OverloadResolutionTestBase.cs (1)

50.Select(x => x.Substring(x.IndexOf("//-", StringComparison.Ordinal) + 3))

Semantics\QueryTests.cs (8)

Semantics\UseSiteErrorTests.cs (1)

1239Assert.DoesNotContain("System.Runtime.CompilerServices.CompilerGeneratedAttribute", diag.GetMessage(), StringComparison.Ordinal);

Compilation\GetSemanticInfoTests.cs (10)

Compilation\GetUnusedImportDirectivesTests.cs (1)

194var position = text.IndexOf("/*here*/", StringComparison.Ordinal);

Compilation\SemanticModelAPITests.cs (13)

Compilation\SemanticModelGetDeclaredSymbolAPITests.cs (35)

Compilation\SymbolSearchTests.cs (9)

DocumentationComments\CrefTests.cs (1)

3378int position = source.IndexOf("{U}", StringComparison.Ordinal);

DocumentationComments\ParameterTests.cs (34)

SymbolDisplay\SymbolDisplayTests.cs (13)

Symbols\AnonymousTypesSemanticsTests.cs (5)

2130int index = source.IndexOf(what, StringComparison.Ordinal); 2134index = source.IndexOf(what, index + 1, StringComparison.Ordinal); 2145if (!line.Trim().StartsWith("//", StringComparison.Ordinal)) 2147for (int index = line.IndexOf("new ", StringComparison.Ordinal); index >= 0;) 2150index = line.IndexOf("new ", index + 1, StringComparison.Ordinal);

Symbols\AnonymousTypesSymbolTests.cs (2)

1461.Where(t => t.Name.StartsWith("<>", StringComparison.Ordinal)) 1477var position = source1.IndexOf("var d", StringComparison.Ordinal) - 1;

Symbols\CompilationCreationTests.cs (1)

2763var path = reference.EndsWith("-resolve", StringComparison.Ordinal) ? _targetDll : reference;

Symbols\ConversionTests.cs (4)

394.FindToken(source.IndexOf("ii", StringComparison.Ordinal)).Parent; 401.FindToken(source.IndexOf("jj)", StringComparison.Ordinal)).Parent; 407.FindToken(source.IndexOf("ss)", StringComparison.Ordinal)).Parent; 414var position = source.IndexOf("//", StringComparison.Ordinal);

Symbols\ExtensionMethodTests.cs (2)

2727var node = tree.GetCompilationUnitRoot().FindToken(code.IndexOf("GetHashCode", StringComparison.Ordinal)).Parent; 2737node = tree.GetCompilationUnitRoot().FindToken(code.IndexOf("Cast<T1>", StringComparison.Ordinal)).Parent;

Symbols\Metadata\MetadataMemberTests.cs (1)

486AssertEx.None(type.GetMembersUnordered(), symbol => symbol.Name.StartsWith("_VtblGap", StringComparison.Ordinal));

Symbols\Metadata\PE\TypeForwarders.cs (18)

Symbols\Source\DeclaringSyntaxNodeTests.cs (3)

139int position = code.IndexOf(name, StringComparison.Ordinal); 154int position = code.IndexOf(textToSearchFor, StringComparison.Ordinal); 261int posA1 = text.IndexOf("a1", StringComparison.Ordinal);

Symbols\Source\EventTests.cs (2)

305var eventSymbol1 = semanticModel.LookupSymbols(text.IndexOf("/*anchorE_1*/", StringComparison.Ordinal), name: "E1").SingleOrDefault() as IEventSymbol; 308var eventSymbol2 = semanticModel.LookupSymbols(text.IndexOf("/*anchorE_2*/", StringComparison.Ordinal), name: "E1").SingleOrDefault() as IEventSymbol;

Symbols\Source\MethodTests.cs (3)

1361var classBMethodM = (MethodSymbol)classB.GetMembers().Single(sym => sym.Name.EndsWith("M", StringComparison.Ordinal)); 1382var classCBaseMethodM = (MethodSymbol)classCBase.GetMembers().Single(sym => sym.Name.EndsWith("M", StringComparison.Ordinal)); 2083var keywordPos = source.IndexOf("string", StringComparison.Ordinal);

Symbols\SymbolErrorTests.cs (2)

18461Assert.True(methods.Any(n => n.StartsWith("A..ctor", StringComparison.Ordinal))); 18462Assert.False(methods.Any(n => n.StartsWith("B..ctor", StringComparison.Ordinal))); // Haven't tried to emit it

Symbols\TypeResolutionTests.cs (1)

129var strcmpSym = c.Assembly.GetTypeByReflectionType(typeof(StringComparison));

Diagnostics\DiagnosticTest.cs (4)

217if (errorCodeName.StartsWith("WRN", StringComparison.Ordinal)) 222else if (errorCodeName.StartsWith("ERR", StringComparison.Ordinal)) 255if (errorCodeName.StartsWith("WRN", StringComparison.Ordinal)) 2413int index = s.IndexOf(textToFind, StringComparison.Ordinal);

Diagnostics\LocationsTests.cs (5)

69int index = s.IndexOf(textToFind, StringComparison.Ordinal); 89TextSpan xSpan = new TextSpan(sampleProgram.IndexOf("x;", StringComparison.Ordinal), 2); 455var token = syntaxTree.GetCompilationUnitRoot().FindToken(sampleProgram.IndexOf("ct", StringComparison.Ordinal)); 490TextSpan span1 = new TextSpan(sampleProgram.IndexOf("i;", StringComparison.Ordinal), 2); 491TextSpan span2 = new TextSpan(sampleProgram.IndexOf("c;", StringComparison.Ordinal), 2);

IncrementalParsing\IncrementalParsingTests.cs (23)

LexicalAndXml\CrefLexerTests.cs (1)

443Assert.DoesNotContain("'", text, StringComparison.Ordinal);

LexicalAndXml\NameAttributeValueLexerTests.cs (1)

407Assert.DoesNotContain("'", text, StringComparison.Ordinal);

LexicalAndXml\PreprocessorTests.cs (1)

3558Assert.Contains("100", diagnostics.First().ToString(), StringComparison.Ordinal); // one-based line number

Parsing\DeclarationParsingTests.cs (2)

5894Assert.Contains(desiredText, stmtText, StringComparison.Ordinal); 5895Assert.DoesNotContain(undesiredText, stmtText, StringComparison.Ordinal);

Syntax\SyntaxDiffingTests.cs (5)

292var index = original.LastIndexOf(indexText, StringComparison.Ordinal); 299index = original.IndexOf(indexText, StringComparison.Ordinal); 352var index = original.IndexOf(indexText, StringComparison.Ordinal); 356index = original.LastIndexOf(indexText, StringComparison.Ordinal); 364index = original.IndexOf(indexText, StringComparison.Ordinal);

Syntax\SyntaxNodeTests.cs (2)

3441var token = syntaxTree.GetCompilationUnitRoot().FindToken(code.IndexOf("using Lib;", StringComparison.Ordinal)); 3460var trivia = tree.GetCompilationUnitRoot().FindTrivia(code.IndexOf("#r", StringComparison.Ordinal)); // ReferenceDirective.

TextExtensions.cs (3)

33int offset = oldFullText.IndexOf(oldText, StringComparison.Ordinal); 43int offset = oldFullText.IndexOf(oldText, startIndex, StringComparison.Ordinal); // Use an offset to find the first element to replace at 58int offset = oldFullText.IndexOf(existingText, StringComparison.Ordinal);

CSharpTestBase.cs (6)

1716if (exprFullText.StartsWith(StartString, StringComparison.Ordinal)) 1720if (exprFullText.EndsWith(EndString, StringComparison.Ordinal)) 1735if (exprFullText.EndsWith(EndString, StringComparison.Ordinal)) 1739if (exprFullText.StartsWith(StartString, StringComparison.Ordinal)) 1855int start = text.IndexOf(startTag, StringComparison.Ordinal); 1860int end = text.IndexOf(endTag, StringComparison.Ordinal);

Extensions.cs (1)

149if (name.StartsWith(".", StringComparison.Ordinal))

SemanticModelTestBase.cs (6)

30return code.IndexOf(tag, StringComparison.Ordinal) + tag.Length; 68if (exprFullText.StartsWith(startComment, StringComparison.Ordinal)) 71if (exprFullText.EndsWith(endComment, StringComparison.Ordinal)) 79if (exprFullText.EndsWith(endComment, StringComparison.Ordinal)) 82if (exprFullText.StartsWith(startComment, StringComparison.Ordinal)) 140var position = testSrc.IndexOf(subStrForPreprocessNameIndex, StringComparison.Ordinal);

SyntaxTreeExtensions.cs (3)

27int offset = oldFullText.IndexOf(oldText, StringComparison.Ordinal); 35int offset = oldFullText.IndexOf(oldText, startIndex, StringComparison.Ordinal); // Use an offset to find the first element to replace at 48int offset = oldFullText.IndexOf(existingText, StringComparison.Ordinal);

Classification\Worker.cs (1)

133token.Text.EndsWith("u8", StringComparison.OrdinalIgnoreCase))

Rename\CSharpRenameRewriterLanguageService.cs (9)

Simplification\CSharpSimplificationService.Expander.cs (3)

306if (elementName?.Equals(name, StringComparison.Ordinal) == true) 591Debug.Assert(name.StartsWith(originalSimpleName.Identifier.ValueText, StringComparison.Ordinal)); 594if (identifier.ValueText == name && name.EndsWith("Attribute", StringComparison.Ordinal))

Simplification\Simplifiers\NameSimplifier.cs (1)

501if (identifierToken.ValueText != AttributeName && identifierToken.ValueText.EndsWith(AttributeName, StringComparison.Ordinal) && !identifierToken.HasAnnotation(SimplificationHelpers.DoNotSimplifyAnnotation))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\CodeStyle\TypeStyle\TypeStyleHelper.cs (1)

179return methodSymbol.Name.Equals("To" + returnTypeName, StringComparison.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\EmbeddedLanguages\VirtualChars\CSharpVirtualCharService.cs (1)

240if (endDelimiter.Length > 0 && !tokenText.EndsWith(endDelimiter, StringComparison.OrdinalIgnoreCase))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxTriviaExtensions.cs (4)

68if (commentText.StartsWith("//", StringComparison.Ordinal)) 79if (commentText.EndsWith("*/", StringComparison.Ordinal)) 84if (commentText.StartsWith("/*", StringComparison.Ordinal)) 99if (trimmedLine.StartsWith("*", StringComparison.Ordinal))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\FormattingHelpers.cs (2)

26var lastNewLinePos = indent.LastIndexOf(NewLine, StringComparison.Ordinal); 39var lastNewLinePos = leading.LastIndexOf(NewLine, StringComparison.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\CSharpCodeGenerationHelpers.cs (1)

98if (!text.EndsWith(MultiLineCommentTerminator, StringComparison.Ordinal))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\CSharpDeclarationComparer.cs (1)

397comparisonResult = string.Compare(x.ValueText, y.ValueText, StringComparison.OrdinalIgnoreCase);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\EnumMemberGenerator.cs (2)

143if (numericText.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) 149else if (numericText.StartsWith("0b", StringComparison.OrdinalIgnoreCase))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\DocumentationCommentExtensions.cs (1)

20return documentationComment.ToFullString().StartsWith("/**", StringComparison.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\StringExtensions.cs (2)

42var unescaped = identifier.StartsWith("@", StringComparison.Ordinal) 49if (!identifier.StartsWith("@", StringComparison.Ordinal))

Formatting\FormattingMultipleSpanTests.cs (2)

186var startPosition = codeWithMarker.IndexOf("/*1*/", currentIndex, StringComparison.Ordinal); 195var endPosition = codeWithMarker.IndexOf("/*2*/", startPosition, StringComparison.Ordinal);

CommentSelection\AbstractToggleBlockCommentBase.cs (4)

324return _trimmedText.StartsWith(commentInfo.BlockCommentStartString, StringComparison.Ordinal) 325|| _trimmedText.StartsWith(commentInfo.BlockCommentEndString, StringComparison.Ordinal); 334return _trimmedText.EndsWith(commentInfo.BlockCommentStartString, StringComparison.Ordinal) 335|| _trimmedText.EndsWith(commentInfo.BlockCommentEndString, StringComparison.Ordinal);

CommentSelection\CommentUncommentSelectionCommandHandler.cs (6)

218if (trimmedSpanText.StartsWith(info.BlockCommentStartString, StringComparison.Ordinal) && trimmedSpanText.EndsWith(info.BlockCommentEndString, StringComparison.Ordinal)) 220var positionOfStart = span.Start + spanText.IndexOf(info.BlockCommentStartString, StringComparison.Ordinal); 221var positionOfEnd = span.Start + spanText.LastIndexOf(info.BlockCommentEndString, StringComparison.Ordinal); 281if (lineText.Trim().StartsWith(info.SingleLineCommentString, StringComparison.Ordinal)) 283DeleteText(textChanges, new TextSpan(line.Start.Position + lineText.IndexOf(info.SingleLineCommentString, StringComparison.Ordinal), info.SingleLineCommentString.Length));

CommentSelection\ToggleLineCommentCommandHandler.cs (1)

185return lineText.Trim().StartsWith(info.SingleLineCommentString, StringComparison.Ordinal) || line.IsEmptyOrWhitespace();

DocumentationComments\CopilotGenerateDocumentationCommentProvider.cs (12)

EditorConfigSettings\Updater\SettingsUpdateHelper.cs (3)

182string.Equals(key, optionName, StringComparison.OrdinalIgnoreCase)) 247return mostRecentHeaderText.Equals("*", StringComparison.Ordinal); 267return !string.IsNullOrWhiteSpace(currentLineText) && !currentLineText.Trim().StartsWith("#", StringComparison.OrdinalIgnoreCase);

InlineRename\AbstractEditorInlineRenameService.SymbolRenameInfo.cs (3)

93var index = triggerText.LastIndexOf(searchName, StringComparison.Ordinal); 107var position = triggerText.LastIndexOf(replacementText, StringComparison.Ordinal); 113var index = triggerText.LastIndexOf(replacementText + AttributeSuffix, StringComparison.Ordinal);

IntelliSense\AsyncCompletion\Helpers.cs (3)

163using var _ = PooledDelegates.GetPooledFunction(static (filterText, pattern) => filterText.StartsWith(pattern, StringComparison.CurrentCultureIgnoreCase), textTypedSoFar, out Func<string, bool> isPrefixMatch); 166return item.DisplayText.StartsWith(textTypedSoFar, StringComparison.CurrentCultureIgnoreCase) || 167item.HasDifferentFilterText && item.FilterText.StartsWith(textTypedSoFar, StringComparison.CurrentCultureIgnoreCase) ||

IntelliSense\AsyncCompletion\ItemManager.CompletionListUpdater.cs (2)

423!string.Equals(_filterText, typedChar.ToString(), StringComparison.OrdinalIgnoreCase) && 542hardSelect = !_hasSuggestedItemOptions && bestMatchResult.Value.FilterTextUsed.StartsWith(_filterText, StringComparison.CurrentCultureIgnoreCase);

Interactive\InteractiveWindowResetCommand.cs (1)

99var index = arguments.IndexOf(NoConfigParameterName, startIndex, StringComparison.Ordinal);

Peek\PeekableItemSource.cs (1)

47if (!string.Equals(session.RelationshipName, PredefinedPeekRelationships.Definitions.Name, StringComparison.OrdinalIgnoreCase))

RenameTracking\RenameTrackingTaggerProvider.TrackingSession.cs (3)

266var comparison = isRenamingDeclaration || syntaxFactsService.IsCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;

Classification\AbstractClassifierTests.cs (1)

46var start = allCode.IndexOf(code, StringComparison.Ordinal);

Completion\AbstractCompletionProviderTests.cs (2)

984Assert.DoesNotContain("+", description.Text, StringComparison.Ordinal); 988Assert.Contains(GetExpectedOverloadSubstring(expectedSymbols), description.Text, StringComparison.Ordinal);

NavigateTo\AbstractNavigateToTests.cs (1)

181Assert.Contains(expectedItem.SecondarySort, actualItem.SecondarySort, StringComparison.Ordinal);

Workspaces\EditorTestWorkspace.cs (1)

349.ThenBy(kvp => markup.IndexOf("{|" + kvp.Key + ":", StringComparison.Ordinal));

Workspaces\TestWorkspaceFixture.cs (1)

37if (markup.TrimStart().StartsWith("<Workspace>", StringComparison.OrdinalIgnoreCase))

CodeGeneration\CodeGenerationTests.cs (2)

190while (expected.IndexOf("$$", StringComparison.Ordinal) != -1) 261Assert.True(exception != null && exception.Message.StartsWith(expectedMessage, StringComparison.Ordinal),

CommentSelection\CommentUncommentSelectionCommandHandlerTests.cs (1)

817var index = textView.TextSnapshot.GetText().IndexOf(marker, StringComparison.Ordinal);

Extensions\IProjectionBufferFactoryServiceExtensionsTests.cs (1)

45Assert.True(line.GetText().StartsWith("line", StringComparison.Ordinal));

MetadataUtilities.cs (5)

58if (hasNoAssemblyRefs || metadata.Name.Equals("System.Private.CoreLib.dll", StringComparison.OrdinalIgnoreCase)) 440return moduleName.StartsWith("windows.", StringComparison.OrdinalIgnoreCase) && 441moduleName.EndsWith(".winmd", StringComparison.OrdinalIgnoreCase) && 442!moduleName.Equals("windows.winmd", StringComparison.OrdinalIgnoreCase); 447return assemblyName.Equals("windows", StringComparison.OrdinalIgnoreCase);

PDB\MethodDebugInfo.Native.cs (1)

39string.Equals(LocalName, other.LocalName, StringComparison.Ordinal);

PseudoVariableUtilities.cs (2)

44Debug.Assert(name.StartsWith("$ReturnValue", StringComparison.OrdinalIgnoreCase)); 67alias.FullName.StartsWith("$ReturnValue", StringComparison.OrdinalIgnoreCase));

FunctionResolverBase.cs (1)

158return moduleName.Equals(name, StringComparison.OrdinalIgnoreCase);

src\Compilers\CSharp\Portable\Symbols\Synthesized\GeneratedNameParser.cs (7)

17=> name.StartsWith(GeneratedNameConstants.SynthesizedLocalNamePrefix, StringComparison.Ordinal); 35if (name.StartsWith("CS$<", StringComparison.Ordinal)) 39else if (name.StartsWith("<", StringComparison.Ordinal)) 166if (typeParameterName.StartsWith("<", StringComparison.Ordinal) && 167typeParameterName.EndsWith(">j__TPar", StringComparison.Ordinal)) 181if (fieldName.StartsWith("<", StringComparison.Ordinal) && 182fieldName.EndsWith(">P", StringComparison.Ordinal))

src\ExpressionEvaluator\Core\Source\ResultProvider\Helpers\GeneratedMetadataNames.cs (1)

21return name.StartsWith("<", StringComparison.Ordinal) || (name.IndexOf('$') >= 0);

src\ExpressionEvaluator\Core\Source\ResultProvider\Helpers\MemberAndDeclarationInfo.cs (1)

262var comp = string.Compare(x.DisplayName, y.DisplayName, StringComparison.Ordinal);

src\ExpressionEvaluator\Core\Source\ResultProvider\Helpers\TypeHelpers.cs (2)

437type.Name.StartsWith(TupleTypeNamePrefix, StringComparison.Ordinal)) 833return string.Equals(nameA, nameB, StringComparison.Ordinal);

src\ExpressionEvaluator\Core\Source\ResultProvider\ResultProvider.cs (1)

529if (!string.Equals(declaredTypeNameNoTupleElementNames, runtimeTypeName, StringComparison.Ordinal)) // Names will reflect "dynamic", types will not.

Debugger\Engine\DkmClrType.cs (2)

300if (string.Equals(argumentType, "System.String", System.StringComparison.Ordinal)) 306else if (string.Equals(argumentType, "System.Type", System.StringComparison.Ordinal))

Debugger\Engine\DkmClrValue.cs (1)

708if (string.Equals(module.Name, moduleName, StringComparison.OrdinalIgnoreCase))

src\ExpressionEvaluator\Core\Source\ResultProvider\Helpers\GeneratedMetadataNames.cs (1)

21return name.StartsWith("<", StringComparison.Ordinal) || (name.IndexOf('$') >= 0);

src\ExpressionEvaluator\Core\Source\ResultProvider\Helpers\MemberAndDeclarationInfo.cs (1)

262var comp = string.Compare(x.DisplayName, y.DisplayName, StringComparison.Ordinal);

src\ExpressionEvaluator\Core\Source\ResultProvider\Helpers\TypeHelpers.cs (2)

437type.Name.StartsWith(TupleTypeNamePrefix, StringComparison.Ordinal)) 833return string.Equals(nameA, nameB, StringComparison.Ordinal);

src\ExpressionEvaluator\Core\Source\ResultProvider\ResultProvider.cs (1)

529if (!string.Equals(declaredTypeNameNoTupleElementNames, runtimeTypeName, StringComparison.Ordinal)) // Names will reflect "dynamic", types will not.

LanguageServices\FSharpVisualStudioWorkspaceExtensions.cs (1)

24var projects = workspace.CurrentSolution.Projects.Where(p => string.Equals(p.OutputFilePath, filePath, StringComparison.OrdinalIgnoreCase)).ToList();

RazorAnalyzerAssemblyResolver.cs (1)

87if (!Path.GetFileName(directory.AsSpan().TrimEnd(Path.DirectorySeparatorChar)).Equals(ServiceHubCoreFolderName, StringComparison.OrdinalIgnoreCase))

AddImport\PackageSourceHelper.cs (2)

47return uri.Host.EndsWith($".{NugetOrg}", StringComparison.OrdinalIgnoreCase) 48|| uri.Host.Equals(NugetOrg, StringComparison.OrdinalIgnoreCase);

AddMissingReference\AddMissingReferenceCodeAction.cs (1)

54string.Equals(missingAssemblyIdentity.Name, candidateProject.AssemblyName, StringComparison.OrdinalIgnoreCase))

CodeFixes\Configuration\ConfigurationUpdater.cs (6)

472key.Equals("is_global", StringComparison.OrdinalIgnoreCase) && 473value.Trim().Equals("true", StringComparison.OrdinalIgnoreCase) && 522if (key.StartsWith(DiagnosticOptionPrefix, StringComparison.Ordinal)) 528foundMatch = string.Equals(diagId, _diagnostic.Id, StringComparison.OrdinalIgnoreCase); 542if (key.StartsWith(BulkConfigureAnalyzerDiagnosticsByCategoryOptionPrefix, StringComparison.Ordinal)) 546foundMatch = string.Equals(category, _categoryToBulkConfigure, StringComparison.OrdinalIgnoreCase);

CodeLens\CodeLensFindReferenceProgress.cs (1)

81StringComparison.OrdinalIgnoreCase))

CodeLens\LocationComparer.cs (1)

22x.SourceTree.FilePath.Equals(y.SourceTree.FilePath, StringComparison.OrdinalIgnoreCase);

CodeRefactorings\MoveType\AbstractMoveTypeService.cs (2)

203if (typeName.Equals(documentNameWithoutExtension, StringComparison.CurrentCulture)) 206if ($"{typeName}`{arity}".Equals(documentNameWithoutExtension, StringComparison.CurrentCulture))

Completion\CompletionHelper.cs (3)

174var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;

Completion\CompletionItem.cs (1)

208if (!DisplayText.Equals(filterText ?? "", StringComparison.Ordinal))

Completion\Providers\AbstractContextVariableArgumentProvider.cs (3)

70&& !string.Equals(candidate.Name, context.Parameter.Name, StringComparison.OrdinalIgnoreCase)) 158if (string.Equals(bestSymbol.Name, context.Parameter.Name, StringComparison.OrdinalIgnoreCase)) 159return string.Equals(symbol.Name, context.Parameter.Name, StringComparison.OrdinalIgnoreCase);

Completion\Providers\ImportCompletionProvider\ExtensionMethodImportCompletionHelper.SymbolComputer.cs (1)

404if (filterReceiverTypeName.Length > 0 && !string.Equals(filterReceiverTypeName, GetReceiverTypeName(method.Parameters[0].Type), StringComparison.Ordinal))

ConvertNumericLiteral\AbstractConvertNumericLiteralCodeRefactoringProvider.cs (2)

64: prefix.Equals(hexPrefix, StringComparison.OrdinalIgnoreCase) ? NumericKind.Hexadecimal 65: prefix.Equals(binaryPrefix, StringComparison.OrdinalIgnoreCase) ? NumericKind.Binary

DocumentationComments\AbstractDocumentationCommentSnippetService.cs (2)

400if (!previousLineText.StartsWith(ExteriorTriviaText, StringComparison.Ordinal)) 406text.Lines[currentLine.LineNumber + 1].ToString().Trim().StartsWith(ExteriorTriviaText, StringComparison.Ordinal);

EditAndContinue\EditAndContinueDiagnosticDescriptors.cs (1)

219=> diagnosticId.StartsWith("ENC", StringComparison.Ordinal) && int.TryParse(diagnosticId[3..], out var id) ? (RudeEditKind)id : RudeEditKind.None;

EditAndContinue\EditSession.cs (2)

1321EditAndContinueMethodDebugInfoReader.IgnoreCaseWhenComparingDocumentNames ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal));

EditAndContinue\SourceFileSpan.cs (2)

65=> Span.Equals(other.Span) && string.Equals(Path, other.Path, StringComparison.Ordinal); 86=> Span.Contains(span.Span) && string.Equals(Path, span.Path, StringComparison.Ordinal);

EditAndContinue\Utilities\Extensions.cs (4)

106LanguageNames.CSharp => filePath.EndsWith(".g.i.cs", StringComparison.OrdinalIgnoreCase), 107LanguageNames.VisualBasic => filePath.EndsWith(".g.i.vb", StringComparison.OrdinalIgnoreCase), 112=> filePath.EndsWith(".razor.g.cs", StringComparison.OrdinalIgnoreCase) || 113filePath.EndsWith(".cshtml.g.cs", StringComparison.OrdinalIgnoreCase);

GenerateType\AbstractGenerateTypeService.cs (2)

174return state.IsAttribute && !state.NameIsVerbatim && !state.Name.EndsWith(AttributeSuffix, StringComparison.Ordinal) 277if (namespaceSymbol != null && namespaceSymbol.ToDisplayString().StartsWith(includeUsingsOrImports, StringComparison.Ordinal))

GenerateType\AbstractGenerateTypeService.Editor.cs (4)

169namespaceToGenerateInto.StartsWith(rootNamespace + ".", StringComparison.Ordinal)) 241if (namespaceToGenerateInto.StartsWith(rootNamespace + ".", StringComparison.Ordinal)) 594where m.Name.Equals(expectedFieldName, StringComparison.OrdinalIgnoreCase) 600var symbol = membersArray.FirstOrDefault(m => m.Name.Equals(expectedFieldName, StringComparison.Ordinal)) ?? membersArray.FirstOrDefault();

InlineHints\AbstractInlineParameterNameHintsService.cs (3)

148if (!firstPrefix.Span.Equals(nextPrefix.Span, StringComparison.Ordinal)) 166if (!firstPrefix.Span.Equals(nextPrefix.Span, StringComparison.Ordinal)) 278suffix.Span[1..].Equals(parameterName.AsSpan()[1..], StringComparison.Ordinal);

MetadataAsSource\DocumentationCommentUtilities.cs (1)

23if (str.StartsWith(docCommentPrefix, StringComparison.Ordinal))

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (2)

288var firstDocument = navigateProject.Documents.First(d => d.FilePath?.Equals(firstDocumentFilePath, StringComparison.OrdinalIgnoreCase) ?? false); 295var sourceDescription = sourceFileInfos.FirstOrDefault(sfi => sfi!.FilePath?.Equals(navigateDocument.FilePath, StringComparison.OrdinalIgnoreCase) ?? false)?.SourceDescription ?? FeaturesResources.from_metadata;

PdbSourceDocument\SourceLinkMap.cs (2)

192if (path.StartsWith(file.Path, StringComparison.OrdinalIgnoreCase)) 199else if (string.Equals(path, file.Path, StringComparison.OrdinalIgnoreCase))

Rename\SymbolicRenameInfo.cs (1)

172triggerToken.ToString().Equals("New", StringComparison.OrdinalIgnoreCase))

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (2)

94=> text.StartsWith(prefix, StringComparison.OrdinalIgnoreCase) && text.Length > prefix.Length && !char.IsLower(text[prefix.Length]); 102.Where(m => setMethodName.Equals(m.Name, StringComparison.OrdinalIgnoreCase))

src\Analyzers\Core\Analyzers\Helpers\DiagnosticHelper.cs (2)

327if (id.StartsWith("JSON", StringComparison.Ordinal)) 337Debug.Assert(id.StartsWith("IDE", StringComparison.Ordinal));

src\Analyzers\Core\Analyzers\MatchFolderAndNamespace\AbstractMatchFolderAndNamespaceDiagnosticAnalyzer.cs (1)

155if (RoslynString.IsNullOrWhiteSpace(expectedNamespace) || expectedNamespace.Equals(currentNamespace, StringComparison.OrdinalIgnoreCase))

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

375if (trimmedPart.StartsWith(categoryPrefix, StringComparison.OrdinalIgnoreCase))

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

473static (field, property) => field.Name.EndsWith(property.Name, StringComparison.OrdinalIgnoreCase),

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (1)

269: string.Equals(ctorParameter.Name, parameterName, StringComparison.OrdinalIgnoreCase);

src\Analyzers\Core\CodeFixes\GenerateConstructor\GenerateConstructorHelpers.cs (2)

274where m.Name.Equals(memberName, StringComparison.OrdinalIgnoreCase) 280return membersArray.FirstOrDefault(m => m.Name.Equals(memberName, StringComparison.Ordinal)) ?? membersArray.FirstOrDefault();

src\Compilers\Core\Portable\DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (1)

52if (id != null && prefix != null && id.StartsWith(prefix, StringComparison.Ordinal))

StackTraceExplorer\StackTraceExplorerService.cs (1)

109if (name.Equals(documentName, StringComparison.OrdinalIgnoreCase))

TaskList\AbstractTaskListService.cs (1)

96length: token.Length, comparisonType: StringComparison.OrdinalIgnoreCase) != 0)

UnusedReferences\UnusedReferencesRemover.cs (1)

31.Where(project => projectFilePath.Equals(project.FilePath, StringComparison.OrdinalIgnoreCase));

Workspace\CompileTimeSolutionProvider.cs (1)

86=> documentState.FilePath != null && documentState.FilePath.EndsWith(RazorEncConfigFileName, StringComparison.OrdinalIgnoreCase);

EditAndContinue\Extensions.cs (1)

44var eoln = str.IndexOf(LineSeparator, i, StringComparison.Ordinal);

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (1)

221if (path.IndexOf("://", StringComparison.Ordinal) >= 0 || path.IndexOfAny(s_invalidPathChars) >= 0)

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (8)

163internal static bool IsSameDirectoryOrChildOf(string child, string parent, StringComparison comparison = StringComparison.OrdinalIgnoreCase) 498return string.Equals(extension, ".dll", StringComparison.OrdinalIgnoreCase) 499|| string.Equals(extension, ".exe", StringComparison.OrdinalIgnoreCase) 517var comparison = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal; 718if (filePath.StartsWith(oldPrefix, StringComparison.Ordinal))

BrokeredServices\Services\BrokeredServiceBridgeManifest\BrokeredServiceBridgeManifestService.cs (3)

45.Where(s => s.Name.StartsWith("Microsoft.CodeAnalysis.LanguageServer.", StringComparison.Ordinal) || 46s.Name.StartsWith("Microsoft.VisualStudio.LanguageServer.", StringComparison.Ordinal) || 47s.Name.StartsWith("Microsoft.VisualStudio.LanguageServices.", StringComparison.Ordinal))];

DotnetCliHelper.cs (1)

46if (line.StartsWith("Base Path", StringComparison.OrdinalIgnoreCase))

HostWorkspace\FileWatching\LspFileChangeWatcher.cs (3)

68private static readonly StringComparison s_stringComparison = RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;

HostWorkspace\FileWatching\SimpleFileChangeWatcher.cs (1)

73if (WatchedDirectory.FilePathCoveredByWatchedDirectories(_watchedDirectories, filePath, StringComparison.Ordinal))

HostWorkspace\LanguageServerWorkspaceFactory.cs (2)

42.Where(f => f.Name.StartsWith("Microsoft.CodeAnalysis.", StringComparison.Ordinal) && !f.Name.Contains("LanguageServer", StringComparison.Ordinal))

HostWorkspace\LoadedProject.cs (1)

66if (string.Equals(filePath, _projectFilePath, StringComparison.OrdinalIgnoreCase))

Testing\TestRunner.TestRunHandler.cs (1)

198return messages.WhereAsArray(static (msg, category) => msg.Category.Equals(category, StringComparison.OrdinalIgnoreCase), requiredCategory);

Handler\Completion\CompletionResultFactory.cs (3)

137if (!lspItem.Label.Equals(item.SortText, StringComparison.Ordinal)) 140if (!lspItem.Label.Equals(item.FilterText, StringComparison.Ordinal)) 491if (!lspItem.Label.Equals(completionChangeNewText, StringComparison.Ordinal))

Handler\InlineCompletions\InlineCompletionsHandler.cs (1)

144var matchingSnippetInfo = snippetInfo.First(s => wordText.Equals(s.Shortcut, StringComparison.OrdinalIgnoreCase));

Handler\InlineCompletions\XmlSnippetParser.CodeSnippet.cs (14)

Protocol\Diagnostic.cs (2)

148&& string.Equals(this.Source, other.Source, StringComparison.Ordinal) 149&& string.Equals(this.Message, other.Message, StringComparison.Ordinal)

Protocol\Extensions\VSProjectContext.cs (2)

81return string.Equals(this.Label, other.Label, StringComparison.Ordinal) 82&& string.Equals(this.Id, other.Id, StringComparison.Ordinal)

Protocol\Internal\Efficiency\OptimizedVSCompletionListJsonConverter.cs (3)

178if (completionItem.SortText != null && !string.Equals(completionItem.SortText, label, StringComparison.Ordinal)) 183if (completionItem.FilterText != null && !string.Equals(completionItem.FilterText, label, StringComparison.Ordinal)) 188if (completionItem.InsertText != null && !string.Equals(completionItem.InsertText, label, StringComparison.Ordinal))

Protocol\Internal\VSInternalIconMapping.cs (1)

120if (!string.Equals(current[i], other[i], StringComparison.Ordinal))

Protocol\Internal\VSInternalKindAndModifier.cs (2)

67string.Equals(this.Kind, other.Kind, StringComparison.Ordinal) && 103if (!string.Equals(modifiers[i], this.Modifier[i], StringComparison.Ordinal))

CodeActions\RunCodeActionsTests.cs (1)

56var documentForB = testLspServer.TestWorkspace.CurrentSolution.Projects.Single().Documents.Single(doc => doc.Name.Equals("B.cs", StringComparison.OrdinalIgnoreCase));

Completion\CompletionTests.cs (2)

954Assert.Contains("ta", results.Items.First().Label, StringComparison.OrdinalIgnoreCase); 1231Assert.Contains("ta", results.Items.First().Label, StringComparison.OrdinalIgnoreCase);

DeclarePublicApiAnalyzer.cs (1)

184if (text.StartsWith(RemovedApiPrefix, StringComparison.Ordinal))

DeclarePublicApiAnalyzer.Impl.cs (3)

678var indexOfReturnType = apiLineText.IndexOf("->", StringComparison.Ordinal); 686var index = apiLineText.IndexOf(publicApiNameToSearch, StringComparison.Ordinal); 844return skippedNamespaces.Any(n => namespaceString.StartsWith(n, StringComparison.Ordinal));

PublicApiFile.cs (2)

29=> path.StartsWith(prefix, StringComparison.Ordinal) && path.EndsWith(DeclarePublicApiAnalyzer.Extension, StringComparison.Ordinal);

src\RoslynAnalyzers\Utilities\Compiler\AdditionalFileProvider.cs (1)

43=> _additionalFiles.FirstOrDefault(x => Path.GetFileName(x.Path).Equals(fileName, StringComparison.OrdinalIgnoreCase));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (8)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IPropertySymbolExtensions.cs (1)

28|| !property.Name.Equals("IsCompleted", StringComparison.Ordinal)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (1)

840=> symbol?.Name.StartsWith("_", StringComparison.Ordinal) == true &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\StringExtensions.cs (1)

24return str.EndsWith(suffix, StringComparison.Ordinal);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\UriExtensions.cs (1)

38if (symbol.Name.Contains(word, StringComparison.OrdinalIgnoreCase))

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (12)

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (2)

166if (xtext.Value.Contains("\r", StringComparison.Ordinal) || xtext.Value.Contains("\n", StringComparison.Ordinal))

src\RoslynAnalyzers\Utilities\Compiler\WordParser.cs (1)

250if (string.Equals(parsedWord, word, StringComparison.OrdinalIgnoreCase))

DeclarePublicApiFix.cs (1)

112TextDocument? additionalDocument = project.AdditionalDocuments.FirstOrDefault(doc => string.Equals(doc.Name, name, StringComparison.OrdinalIgnoreCase));

PublicApiFixHelpers.cs (1)

57return project.AdditionalDocuments.FirstOrDefault(doc => doc.Name.Equals(name, StringComparison.Ordinal));

DeclarePublicAPIAnalyzerTestsBase.cs (1)

309if (!editorconfigText.EndsWith("true", StringComparison.OrdinalIgnoreCase))

BrokeredServiceDescriptors.cs (1)

26name => CommonMethodNameTransforms.CamelCase(name.EndsWith(AsyncSuffix, StringComparison.OrdinalIgnoreCase) ? name.Substring(0, name.Length - AsyncSuffix.Length) : name);

ServiceDescriptors.cs (2)

116Contract.ThrowIfFalse(interfaceName.StartsWith(InterfaceNamePrefix, StringComparison.Ordinal)); 117Contract.ThrowIfFalse(interfaceName.EndsWith(InterfaceNameSuffix, StringComparison.Ordinal));

VisualStudioMefHostServices.cs (2)

85=> string.Compare(ExtensionTypeName, other.ExtensionTypeName, StringComparison.OrdinalIgnoreCase) == 0 && 86string.Compare(MetadataTypeName, other.MetadataTypeName, StringComparison.OrdinalIgnoreCase) == 0;

AbstractResxGenerator.cs (1)

37var resourceFiles = context.AdditionalTextsProvider.Where(static file => file.Path.EndsWith(".resx", StringComparison.OrdinalIgnoreCase));

src\RoslynAnalyzers\Utilities\Compiler\AdditionalFileProvider.cs (1)

43=> _additionalFiles.FirstOrDefault(x => Path.GetFileName(x.Path).Equals(fileName, StringComparison.OrdinalIgnoreCase));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

142var index = symbolName.LastIndexOf(".", StringComparison.OrdinalIgnoreCase);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\CompilationExtensions.cs (3)

35if (string.Equals(propertyValue?.Trim(), "true", StringComparison.OrdinalIgnoreCase)) 42(propertyValue.Contains(WebAppProjectGuidString, StringComparison.OrdinalIgnoreCase) || 43propertyValue.Contains(WebSiteProjectGuidString, StringComparison.OrdinalIgnoreCase)))

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (8)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IPropertySymbolExtensions.cs (1)

28|| !property.Name.Equals("IsCompleted", StringComparison.Ordinal)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (1)

840=> symbol?.Name.StartsWith("_", StringComparison.Ordinal) == true &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\StringExtensions.cs (1)

24return str.EndsWith(suffix, StringComparison.Ordinal);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\UriExtensions.cs (1)

38if (symbol.Name.Contains(word, StringComparison.OrdinalIgnoreCase))

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

403if (!genericInterfaceFullName.StartsWith("T:", StringComparison.Ordinal)) 478(optionValue == null || !optionValue.Contains(arg.optionForcedValue, StringComparison.Ordinal))) 505(optionValue == null || !optionValue.Contains(optionForcedValue, StringComparison.Ordinal)))

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (12)

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (2)

166if (xtext.Value.Contains("\r", StringComparison.Ordinal) || xtext.Value.Contains("\n", StringComparison.Ordinal))

src\RoslynAnalyzers\Utilities\Compiler\WordParser.cs (1)

250if (string.Equals(parsedWord, word, StringComparison.OrdinalIgnoreCase))

Verifiers\CSharpSourceGeneratorVerifier`1+Test.cs (2)

97if (!name.StartsWith(currentTestPrefix, StringComparison.Ordinal)) 116if (!resourceName.StartsWith(expectedPrefix, StringComparison.Ordinal))

Verifiers\VisualBasicSourceGeneratorVerifier`1+Test.cs (2)

82if (!name.StartsWith(currentTestPrefix, StringComparison.Ordinal)) 101if (!resourceName.StartsWith(expectedPrefix, StringComparison.Ordinal))

Hosting\AssemblyLoader\MetadataShadowCopyProvider.cs (3)

148return normalizedPath.StartsWith(directory, StringComparison.OrdinalIgnoreCase); 389if (referencesDir != null && directory.StartsWith(referencesDir, StringComparison.Ordinal)) 394return !_noShadowCopyDirectories.Any(static (dir, directory) => directory.StartsWith(dir, StringComparison.Ordinal), directory);

Hosting\Resolvers\NuGetPackageResolver.cs (1)

22if (reference.StartsWith(ReferencePrefix, StringComparison.Ordinal))

Hosting\Resolvers\RuntimeMetadataReferenceResolver.cs (1)

218if (fileName.EndsWith(".ni", StringComparison.OrdinalIgnoreCase))

src\Compilers\Shared\GlobalAssemblyCacheHelpers\MonoGlobalAssemblyCache.cs (2)

77if (version != null && !assemblyDir.Name.StartsWith(version.ToString(), StringComparison.Ordinal)) 82if (publicKeyToken != null && !assemblyDir.Name.EndsWith(publicKeyToken, StringComparison.Ordinal))

GlobalAssemblyCacheTests.cs (1)

115Assert.True(gacLocationsUpper.Any(gac => location.StartsWith(gac, StringComparison.OrdinalIgnoreCase)), "Path within some GAC root");

Assert\AssertEx.cs (3)

207if (string.Equals(expected, actual, StringComparison.Ordinal)) 612Assert.Contains(expectedSubString, actualString, StringComparison.Ordinal); 619Assert.StartsWith(expectedSubString, actualString, StringComparison.Ordinal);

Assert\ConditionalFactAttribute.cs (3)

175return path.StartsWith(@"\\.\", StringComparison.Ordinal); 250!CultureInfo.CurrentUICulture.Name.StartsWith("en", StringComparison.OrdinalIgnoreCase) || 251!CultureInfo.CurrentCulture.Name.StartsWith("en", StringComparison.OrdinalIgnoreCase);

Compilation\CompilationExtensions.cs (1)

220if (!string.IsNullOrEmpty(symbolToVerify) && !declaration.DeclaredSymbol.Name.Equals(symbolToVerify, StringComparison.Ordinal))

Compilation\CompilationTestDataExtensions.cs (1)

62var keys = map.Keys.Where(k => k.StartsWith(qualifiedMethodName + "(", StringComparison.Ordinal));

Compilation\RuntimeUtilities.cs (1)

37=> IsCoreClrRuntime && RuntimeInformation.FrameworkDescription.StartsWith(".NET 6.", StringComparison.Ordinal);

Diagnostics\CommonDiagnosticAnalyzers.cs (2)

1775return fileNameWithoutExtension.EndsWith(".designer", StringComparison.OrdinalIgnoreCase) || 1776fileNameWithoutExtension.EndsWith(".generated", StringComparison.OrdinalIgnoreCase);

Diagnostics\SuppressMessageAttributeTests.DiagnosticAnalyzers.cs (1)

67if (context.Symbol.Name.StartsWith(_errorSymbolPrefix, StringComparison.Ordinal))

FX\EnsureEnglishUICulture.cs (1)

20if (currentUICultureName.Length == 0 || currentUICultureName.StartsWith("en", StringComparison.OrdinalIgnoreCase))

MarkedSource\MarkupTestFile.cs (1)

204var index = input.IndexOf(value, currentIndex, StringComparison.Ordinal);

Metadata\MetadataValidation.cs (1)

53if (string.Equals(GetAttributeName(metadataReader, caHandle), attributeClassName, StringComparison.Ordinal))

Platform\CoreClr\TestExecutionLoadContext.cs (2)

40var comparison = StringComparison.OrdinalIgnoreCase;

Platform\Custom\MetadataSignatureHelper.cs (1)

35if (sb.ToString().EndsWith(", ", StringComparison.Ordinal))

Platform\Custom\SigningTestHelpers.cs (1)

90StringComparison.OrdinalIgnoreCase);

Syntax\NodeHelpers.cs (1)

54return kind.EndsWith("Keyword", StringComparison.Ordinal) || (kind.Contains("Identifier") && n.Parent != null && !n.Parent.GetKind().Contains("Name"));

AnalyzerAssemblyLoaderTests.cs (2)

425Assert.All(assemblies, x => x.Location.StartsWith(shadowLoader.BaseDirectory, StringComparison.Ordinal)); 438if (path.EndsWith(".resources.dll", StringComparison.Ordinal))

CachingLookupTests.cs (2)

65where string.Equals(GetKey(n, ignoreCase), key, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal)

CommonCommandLineParserTests.cs (1)

994Assert.Contains(string.Format(CodeAnalysisResources.InvalidRuleSetInclude, newFile.Path, string.Format(CodeAnalysisResources.RuleSetBadAttributeValue, "Action", "Default")), e.Message, StringComparison.Ordinal);

FileSystem\PathUtilitiesTests.cs (8)

Declarations\SingleNamespaceDeclaration.vb (1)

90Dim comp = String.Compare(bestDeclarationName, otherName, StringComparison.Ordinal)

Symbols\Attributes\SourceAttributeData.vb (5)

182If Not String.Equals(namedType.MetadataName, targetInfo.Name, StringComparison.Ordinal) OrElse 183Not namedType.HasNameQualifier(targetInfo.Namespace, StringComparison.Ordinal) Then 304Dim options As StringComparison = If(ignoreCase, StringComparison.OrdinalIgnoreCase, StringComparison.Ordinal)

Symbols\MissingModuleSymbol.vb (1)

213Return other IsNot Nothing AndAlso m_Assembly.Equals(other.m_Assembly) AndAlso String.Equals(_name, other._name, StringComparison.OrdinalIgnoreCase)

Symbols\MissingNamespaceSymbol.vb (1)

82Return other IsNot Nothing AndAlso String.Equals(_name, other._name, StringComparison.Ordinal) AndAlso _containingSymbol.Equals(other._containingSymbol)

CompilationContext.vb (9)

FlowAnalysis\IterationJumpYieldStatementTests.vb (1)

1369Dim stmtNode = DirectCast(tree.GetCompilationUnitRoot().FindToken(tree.GetRoot.ToFullString().IndexOf("Next", StringComparison.Ordinal)).Parent, NextStatementSyntax)

FlowAnalysis\TryLockUsingStatementTests.vb (2)

1670Dim index = compilation.SyntaxTrees.First().GetCompilationUnitRoot().ToFullString().IndexOf("Catch ex As Exception", StringComparison.Ordinal) 1699Dim index = compilation.SyntaxTrees.First().GetCompilationUnitRoot().ToFullString().IndexOf("Finally", StringComparison.Ordinal)

Semantics\QueryExpressions_FlowAnalysis.vb (1)

365Dim ss = dataFlowAnalysisResults.WrittenOutside.Where(Function(s) s.Name.Equals("s1", StringComparison.OrdinalIgnoreCase))

SyntaxTreeExtensions.vb (3)

25Dim offset As Integer = oldFullText.IndexOf(oldText, StringComparison.Ordinal) 33Dim offset As Integer = oldFullText.IndexOf(oldText, startIndex, StringComparison.Ordinal) 46Dim offset As Integer = oldFullText.IndexOf(existingText, StringComparison.Ordinal)

Diagnostics\Extensions.cs (3)

101fileNameSpan.Equals("Microsoft.CodeAnalysis.Features.dll".AsSpan(), StringComparison.OrdinalIgnoreCase) || 102fileNameSpan.Equals("Microsoft.CodeAnalysis.CSharp.Features.dll".AsSpan(), StringComparison.OrdinalIgnoreCase) || 103fileNameSpan.Equals("Microsoft.CodeAnalysis.VisualBasic.Features.dll".AsSpan(), StringComparison.OrdinalIgnoreCase);

Rename\ConflictEngine\ConflictResolver.cs (5)

243string.Equals(s.MetadataName, renamedSymbol.MetadataName, StringComparison.Ordinal)); 269string.Equals(s.MetadataName, renamedSymbol.MetadataName, StringComparison.Ordinal)); 278string.Equals(s.MetadataName, renamedSymbol.MetadataName, StringComparison.Ordinal)); 427if (string.Equals(oldMetadataName, newMetadataName, StringComparison.Ordinal)) 457return string.Equals(newMetadataName, oldMetadataName, StringComparison.Ordinal);

Rename\ConflictEngine\MutableConflictResolution.cs (1)

111if (newName.Equals(document.Name, StringComparison.OrdinalIgnoreCase))

Rename\IRenameRewriterLanguageService.cs (1)

142param => string.Compare(param.Name, newPropertyName, StringComparison.OrdinalIgnoreCase) == 0);

Rename\RenameUtilities.cs (1)

201if (string.Equals(member.MetadataName, symbol.MetadataName, StringComparison.Ordinal) && member is IMethodSymbol && !member.Equals(symbol))

Rename\SymbolicRenameLocations.ReferenceProcessing.cs (1)

67string.Compare(TrimNameToAfterLastDot(referencedSymbol.Name), TrimNameToAfterLastDot(originalSymbol.Name), StringComparison.OrdinalIgnoreCase) == 0 &&

Shared\TestHooks\AsynchronousOperationListenerProvider.cs (4)

208s_enabled = string.Equals(enabled, "1", StringComparison.OrdinalIgnoreCase) || string.Equals(enabled, "True", StringComparison.OrdinalIgnoreCase); 229_enableDiagnosticTokens = string.Equals(enabled, "1", StringComparison.OrdinalIgnoreCase) || string.Equals(enabled, "True", StringComparison.OrdinalIgnoreCase);

Shared\Utilities\BloomFilter_Serialization.cs (1)

58if (!string.Equals(version, SerializationFormat, StringComparison.Ordinal))

src\Compilers\Core\Portable\DiagnosticAnalyzer\AnalyzerAssemblyLoader.cs (2)

67internal static readonly (StringComparer Comparer, StringComparison Comparison) SimpleNameComparer = (StringComparer.OrdinalIgnoreCase, StringComparison.OrdinalIgnoreCase);

src\Compilers\Core\Portable\DiagnosticAnalyzer\ProgramFilesAnalyzerPathResolver.cs (1)

39=> analyzerPath.StartsWith(DotNetPath, StringComparison.OrdinalIgnoreCase);

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (1)

221if (path.IndexOf("://", StringComparison.Ordinal) >= 0 || path.IndexOfAny(s_invalidPathChars) >= 0)

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (8)

163internal static bool IsSameDirectoryOrChildOf(string child, string parent, StringComparison comparison = StringComparison.OrdinalIgnoreCase) 498return string.Equals(extension, ".dll", StringComparison.OrdinalIgnoreCase) 499|| string.Equals(extension, ".exe", StringComparison.OrdinalIgnoreCase) 517var comparison = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal; 718if (filePath.StartsWith(oldPrefix, StringComparison.Ordinal))

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

54return string.Equals(name1, name2, fromVb ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase); 59return string.Equals(name1, name2, StringComparison.Ordinal);

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

175var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (2)

705if (!chunk.Span.Equals(array.AsSpan().Slice(chunkOffset, chunk.Length), StringComparison.Ordinal)) 751=> text.Equals(array.AsSpan(), StringComparison.Ordinal);

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (5)

66if (fileName.StartsWith("TemporaryGeneratedFile_", StringComparison.OrdinalIgnoreCase)) 75if (fileNameWithoutExtension.EndsWith(".designer", StringComparison.OrdinalIgnoreCase) || 76fileNameWithoutExtension.EndsWith(".generated", StringComparison.OrdinalIgnoreCase) || 77fileNameWithoutExtension.EndsWith(".g", StringComparison.OrdinalIgnoreCase) || 78fileNameWithoutExtension.EndsWith(".g.i", StringComparison.OrdinalIgnoreCase))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\Section.cs (1)

20private bool IsSplatHeader => Text.Equals("*", StringComparison.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (2)

145if (startDelimiter.Length > 0 && !tokenText.StartsWith(startDelimiter, StringComparison.Ordinal)) 151if (endDelimiter.Length > 0 && !tokenText.EndsWith(endDelimiter, StringComparison.Ordinal))

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

97where kvp.Key.Trim().StartsWith("dotnet_naming_rule.", StringComparison.Ordinal)

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

47if (str.Equals("null", StringComparison.InvariantCultureIgnoreCase)) 78=> new(parseValue: str => str.Equals(emptyStringRepresentation, StringComparison.Ordinal) ? default(Optional<string>) : EscapeLineBreaks(str), 143if (str.Equals("null", StringComparison.InvariantCultureIgnoreCase))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\Option2.cs (3)

69Debug.Assert(LanguageName is null == (Definition.ConfigName.StartsWith(OptionDefinition.LanguageAgnosticConfigNamePrefix, StringComparison.Ordinal) || 71Debug.Assert(LanguageName is LanguageNames.CSharp == Definition.ConfigName.StartsWith(OptionDefinition.CSharpConfigNamePrefix, StringComparison.Ordinal)); 72Debug.Assert(LanguageName is LanguageNames.VisualBasic == Definition.ConfigName.StartsWith(OptionDefinition.VisualBasicConfigNamePrefix, StringComparison.Ordinal));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\PerLanguageOption2.cs (2)

60Debug.Assert(!Definition.ConfigName.StartsWith(OptionDefinition.CSharpConfigNamePrefix, StringComparison.Ordinal)); 61Debug.Assert(!Definition.ConfigName.StartsWith(OptionDefinition.VisualBasicConfigNamePrefix, StringComparison.Ordinal));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.cs (5)

271=> string.Equals(name1, name2, isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase); 365var comparison = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

66if (rootNamespace is not null && @namespace.StartsWith(rootNamespace + ".", StringComparison.OrdinalIgnoreCase))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SignatureComparer.cs (1)

103: string.Equals(identifier1, identifier2, StringComparison.OrdinalIgnoreCase);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (1)

39: string.Equals(x.Name, y.Name, StringComparison.OrdinalIgnoreCase);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\WordSimilarityChecker.cs (1)

124if (_substringsAreSimilar && candidateText.IndexOf(_source, StringComparison.OrdinalIgnoreCase) >= 0)

Telemetry\TelemetryFeatureName.cs (1)

42=> new(type.Assembly.FullName?.StartsWith("Microsoft.", StringComparison.Ordinal) == true ? type.FullName! : "External",

Utilities\SpellChecker.cs (1)

50if (string.Equals(formatVersion, SerializationFormat, StringComparison.Ordinal))

Utilities\WorkspacePathUtilities.cs (1)

20=> GetTypeNameFromDocumentName(document)?.Equals(typeName, StringComparison.OrdinalIgnoreCase) == true;

Workspace\ProjectSystem\IFileChangeWatcher.cs (1)

55public static bool FilePathCoveredByWatchedDirectories(ImmutableArray<WatchedDirectory> watchedDirectories, string filePath, StringComparison stringComparison)

Workspace\ProjectSystem\ProjectSystemProject.cs (3)

939if (!provider.Metadata.Extensions.Any(e => string.Equals(e, extension, StringComparison.OrdinalIgnoreCase))) 1226static (fileName, fullPath) => fullPath.EndsWith(fileName, StringComparison.OrdinalIgnoreCase), fullPath)) 1239private static bool DirectoryNameEndsWith(string fullPath, string ending) => fullPath.LastIndexOf(ending, StringComparison.OrdinalIgnoreCase) + ending.Length - 1 ==

Workspace\ProjectSystem\ProjectSystemProjectFactory.cs (3)

561&& string.Equals(peReference.FilePath, outputPath, StringComparison.OrdinalIgnoreCase)) 660if (string.Equals(convertedReference.path, outputPath, StringComparison.OrdinalIgnoreCase) && 892if (fullFilePath.Equals(getFilePath(oldReference), StringComparison.OrdinalIgnoreCase))

Workspace\Host\Mef\MefV1HostServices.cs (2)

125return string.Compare(this.ExtensionTypeName, other.ExtensionTypeName, StringComparison.OrdinalIgnoreCase) == 0 126&& string.Compare(this.MetadataTypeName, other.MetadataTypeName, StringComparison.OrdinalIgnoreCase) == 0;

MSBuild\MSBuildProjectLoader.SolutionFilterReader.cs (1)

20return Path.GetExtension(filename).Equals(".slnf", StringComparison.OrdinalIgnoreCase);

MSBuild\MSBuildProjectLoader.Worker.AnalyzerReferencePathComparer.cs (1)

22=> string.Equals(x?.FullPath, y?.FullPath, StringComparison.OrdinalIgnoreCase);

src\Workspaces\MSBuild\BuildHost\Rpc\Contracts\MonoMSBuildDiscovery.cs (1)

157s_monoMSBuildDirectory = versionDirectory.EnumerateDirectories().SingleOrDefault(d => string.Equals(d.Name, "bin", StringComparison.OrdinalIgnoreCase))?.FullName;

MSBuild\ProjectFile\CommandLineArgumentReader.cs (2)

231if (prefer32bit && (RoslynString.IsNullOrWhiteSpace(platform) || string.Equals("anycpu", platform, StringComparison.OrdinalIgnoreCase))) 259if (string.Equals(alias, "global", StringComparison.OrdinalIgnoreCase))

MSBuild\ProjectFile\Conversions.cs (2)

16&& (string.Equals(bool.TrueString, value, StringComparison.OrdinalIgnoreCase) || 17string.Equals("On", value, StringComparison.OrdinalIgnoreCase));

MSBuild\ProjectFile\Extensions.cs (1)

72!string.Equals(referenceOutputAssemblyText, bool.FalseString, StringComparison.OrdinalIgnoreCase);

MSBuild\ProjectFile\ProjectFile.cs (7)

242=> !Path.GetFileName(item.ItemSpec).StartsWith("TemporaryGeneratedFile_", StringComparison.Ordinal); 347if (normalizedPath.StartsWith(projectDirectory, StringComparison.OrdinalIgnoreCase)) 442item = references.FirstOrDefault(it => string.Compare(it.EvaluatedInclude, shortAssemblyName, StringComparison.OrdinalIgnoreCase) == 0); 447item = references.FirstOrDefault(it => string.Compare(it.EvaluatedInclude, fullAssemblyName, StringComparison.OrdinalIgnoreCase) == 0); 463var items = references.Where(it => it.EvaluatedInclude.StartsWith(partialName, StringComparison.OrdinalIgnoreCase)).ToList(); 473=> item.Metadata.FirstOrDefault(m => string.Equals(m.Name, MetadataNames.HintPath, StringComparison.OrdinalIgnoreCase))?.EvaluatedValue ?? string.Empty; 527item ??= references.First(it => string.Compare(projectName, it.GetMetadataValue(MetadataNames.Name), StringComparison.OrdinalIgnoreCase) == 0);

MSBuild\VisualBasic\VisualBasicCommandLineArgumentReader.cs (5)

88if (string.Equals("binary", optionCompare, StringComparison.OrdinalIgnoreCase)) 92else if (string.Equals("text", optionCompare, StringComparison.OrdinalIgnoreCase)) 110if (string.Equals("default", vbRuntime, StringComparison.OrdinalIgnoreCase)) 114else if (string.Equals("embed", vbRuntime, StringComparison.OrdinalIgnoreCase)) 118else if (string.Equals("none", vbRuntime, StringComparison.OrdinalIgnoreCase))

Rpc\Contracts\MonoMSBuildDiscovery.cs (1)

157s_monoMSBuildDirectory = versionDirectory.EnumerateDirectories().SingleOrDefault(d => string.Equals(d.Name, "bin", StringComparison.OrdinalIgnoreCase))?.FullName;

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (1)

221if (path.IndexOf("://", StringComparison.Ordinal) >= 0 || path.IndexOfAny(s_invalidPathChars) >= 0)

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (8)

163internal static bool IsSameDirectoryOrChildOf(string child, string parent, StringComparison comparison = StringComparison.OrdinalIgnoreCase) 498return string.Equals(extension, ".dll", StringComparison.OrdinalIgnoreCase) 499|| string.Equals(extension, ".exe", StringComparison.OrdinalIgnoreCase) 517var comparison = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal; 718if (filePath.StartsWith(oldPrefix, StringComparison.Ordinal))

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

54return string.Equals(name1, name2, fromVb ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase); 59return string.Equals(name1, name2, StringComparison.Ordinal);

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

175var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;

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

751=> text.Equals(array.AsSpan(), StringComparison.Ordinal);

FileSet.cs (2)

62var startTagStart = textContent.IndexOf(elementStartTag, StringComparison.Ordinal); 68var endTagStart = textContent.IndexOf(elementEndTag, startTagEnd + 1, StringComparison.Ordinal);

MSBuildWorkspaceTestBase.cs (1)

147var solutionFileName = files.First(t => t.fileName.EndsWith(".sln", StringComparison.OrdinalIgnoreCase)).fileName;

VisualStudioMSBuildWorkspaceTests.cs (10)

MEF\TestComposition.cs (3)

199name.EndsWith(".Tests", StringComparison.OrdinalIgnoreCase) || 200name.EndsWith(".UnitTests", StringComparison.OrdinalIgnoreCase) || 201name.IndexOf("Test.Utilities", StringComparison.OrdinalIgnoreCase) >= 0;

WorkspaceExtensions.cs (1)

55=> solution.Projects.Where(p => string.Compare(p.Name, name, StringComparison.OrdinalIgnoreCase) == 0);

Workspaces\TestWorkspace_XmlConsumption.cs (2)

136if (string.Compare(projectFilePath, NullFilePath, StringComparison.Ordinal) == 0) 950=> text.TrimStart('\r', '\n', ' ').StartsWith("<Workspace>", StringComparison.Ordinal);

FindAllDeclarationsTests.TestSolutionsAndProject.cs (1)

70string.Equals(actualResult, expectedResult, StringComparison.Ordinal),

Remote\ServiceDescriptorTests.cs (2)

87type.Namespace == "System" && type.Name.StartsWith("ValueTuple", StringComparison.Ordinal) || 88type.Namespace == "System" && type.Name.StartsWith("Tuple", StringComparison.Ordinal))

SyntaxPathTests.cs (2)

412var offset = oldFullText.IndexOf(oldText, StringComparison.Ordinal); 437offset: syntaxTree.GetText().ToString().IndexOf(oldText, startIndex, StringComparison.Ordinal),

UtilityTest\NameGeneratorTests.cs (9)

Microsoft\CSharp\RuntimeBinder\RuntimeBinder.cs (4)

300if (callOrInvoke.Name.StartsWith("set_", StringComparison.Ordinal) || 301callOrInvoke.Name.StartsWith("get_", StringComparison.Ordinal)) 834if ((payload.Name.StartsWith("set_", StringComparison.Ordinal) && ((MethodSymbol)swt.Sym).Params.Count > 1) || 835(payload.Name.StartsWith("get_", StringComparison.Ordinal) && ((MethodSymbol)swt.Sym).Params.Count > 0))

Microsoft\CSharp\RuntimeBinder\Semantics\MemberLookup.cs (2)

148(!symCur.name.Text.StartsWith("set_", StringComparison.Ordinal) || meth.Params.Count <= 1) && 149(!symCur.name.Text.StartsWith("get_", StringComparison.Ordinal) || meth.Params.Count <= 0))

DataFrame.cs (1)

555else if (stringValue.Equals("null", StringComparison.OrdinalIgnoreCase))

DataFrame.IO.cs (1)

30if (string.Equals(columnValue, "null", StringComparison.OrdinalIgnoreCase))

TextFieldParser.cs (3)

612if (trimmedLine.StartsWith(Token, StringComparison.Ordinal)) 616if (line.StartsWith(Token, StringComparison.Ordinal)) 1044if (token != string.Empty && (_hasFieldsEnclosedInQuotes && (_textFieldType == FieldType.Delimited)) && string.Compare(token.Trim(), "\"", StringComparison.Ordinal) == 0)

DataFrame.IOTests.cs (1)

1657if (string.IsNullOrEmpty(item) || string.Equals(item, "null", StringComparison.OrdinalIgnoreCase))

src\Microsoft.Data.Analysis\TextFieldParser.cs (3)

612if (trimmedLine.StartsWith(Token, StringComparison.Ordinal)) 616if (line.StartsWith(Token, StringComparison.Ordinal)) 1044if (token != string.Empty && (_hasFieldsEnclosedInQuotes && (_textFieldType == FieldType.Delimited)) && string.Compare(token.Trim(), "\"", StringComparison.Ordinal) == 0)

src\Common\Internal\AssemblyResolution.cs (1)

28if (!name.Name.Equals("System.Collections.Immutable", StringComparison.OrdinalIgnoreCase))

src\DownloadFile.cs (2)

111if (uri.StartsWith(FileUriProtocol, StringComparison.Ordinal)) 190httpResponse.ReasonPhrase.StartsWith("The requested URI does not represent any resource on the server.", StringComparison.OrdinalIgnoreCase))

src\GenerateSourcePackageSourceLinkTargetsFile.cs (2)

51if (itemSpec.Length > projectDir.Length && itemSpec.StartsWith(projectDir, StringComparison.Ordinal)) 57if (!projectDir.StartsWith(itemSpec, StringComparison.Ordinal) ||

src\GetLicenseFilePath.cs (1)

45.Where(path => string.Equals(fileNameWithExtension, System.IO.Path.GetFileName(path), System.StringComparison.OrdinalIgnoreCase));

src\InstallDotNetCore.cs (2)

102if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && string.Equals("x86", architecture, StringComparison.OrdinalIgnoreCase)) 193else if (!string.IsNullOrWhiteSpace(Platform) && !string.Equals(Platform, "AnyCpu", StringComparison.OrdinalIgnoreCase))

PipelinesLogger.cs (1)

282projectFile.StartsWith(_solutionDirectory + @"\", StringComparison.OrdinalIgnoreCase))

MarkdownDiffExporter.cs (1)

137if (string.Equals(left, right, StringComparison.OrdinalIgnoreCase))

ArtifactModel.cs (1)

100StringComparison.OrdinalIgnoreCase) == false)

BuildModelFactory.cs (14)

VersionIdentifier.cs (1)

167(prevDelimiterCharacter != '-' || !_knownTags.Any(tag => nextSegment.StartsWith(tag, StringComparison.OrdinalIgnoreCase))))

BuildModelFactoryTests.cs (1)

787_buildEngine.BuildErrorEvents.Should().Contain(e => e.Message.Contains($"Build identity properties mismatch in manifest '': {propertyName}: expected '{valueA}', found '{valueB}'", StringComparison.OrdinalIgnoreCase));

src\AzureStorageExtensions.cs (1)

32return blobMD5.Equals(localMD5, StringComparison.OrdinalIgnoreCase);

src\common\AzureStorageUtils.cs (1)

273if (!localMD5.Equals(md5.Single(), StringComparison.OrdinalIgnoreCase))

src\common\GeneralUtils.cs (3)

231if (assetId.EndsWith(SymbolPackageSuffix, StringComparison.OrdinalIgnoreCase)) 251return name.EndsWith(SymbolPackageSuffix, StringComparison.OrdinalIgnoreCase) || 252name.EndsWith(SnupkgPackageSuffix, StringComparison.OrdinalIgnoreCase);

src\common\LatestLinksManager.cs (1)

101if (!feedBaseUrl.EndsWith("/", StringComparison.OrdinalIgnoreCase))

src\model\SetupTargetFeedConfigV3.cs (3)

268if (feed.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) 281if (feed.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) 294if (feed.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))

src\model\SetupTargetFeedConfigV4.cs (3)

213if (feed.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) 226if (feed.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) 239if (feed.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))

src\model\TargetFeedConfig.cs (1)

100((TargetURL is null && other.TargetURL is null) || TargetURL.Equals(other.TargetURL, StringComparison.OrdinalIgnoreCase)) &&

src\BuildFPMToolPreReqs.cs (2)

278if (argument.StartsWith("\"", StringComparison.Ordinal) && 279argument.EndsWith("\"", StringComparison.Ordinal))

src\StabilizeWixFileId.cs (1)

73?.EndsWith(file.ItemSpec, StringComparison.OrdinalIgnoreCase) == true)

CreateTrimDependencyGroups.cs (1)

165if (!runtimeAssets.Any(r => Path.GetFileName(r).Equals(fileName, StringComparison.OrdinalIgnoreCase)))

GenerateNuSpec.cs (1)

257where !f.GetMetadata(Metadata.FileTarget).StartsWith("$none$", StringComparison.OrdinalIgnoreCase)

HarvestPackage.cs (5)

584if (parts[0].Equals("lib", StringComparison.OrdinalIgnoreCase) || 585parts[0].Equals("ref", StringComparison.OrdinalIgnoreCase)) 591parts[0].Equals("runtimes", StringComparison.OrdinalIgnoreCase) && 592parts[2].Equals("lib", StringComparison.OrdinalIgnoreCase)) 610return path.StartsWith("ref", StringComparison.OrdinalIgnoreCase);

NugetPropertyStringProvider.cs (1)

45var indexOfEquals = propertyString.IndexOf("=", StringComparison.Ordinal);

PackageIndex.cs (1)

709var version = versionString.Equals(AnyVersion, StringComparison.OrdinalIgnoreCase) ? VersionUtility.MaxVersion : new Version(versionString);

PackageItem.cs (3)

31IsDll = Path.GetExtension(SourcePath).Equals(".dll", StringComparison.OrdinalIgnoreCase); 33IsRef = TargetPath.StartsWith("ref/", StringComparison.OrdinalIgnoreCase); 49if (!Path.GetExtension(TargetPath).Equals(Path.GetExtension(sourceFile), StringComparison.OrdinalIgnoreCase) ||

PromoteDependencies.cs (1)

106IsReference = item.GetMetadata("TargetPath").StartsWith("ref/", System.StringComparison.OrdinalIgnoreCase);

UpdatePackageIndex.cs (1)

244var dlls = reader.GetFiles().Where(f => Path.GetExtension(f).Equals(".dll", StringComparison.OrdinalIgnoreCase));

ValidatePackage.cs (2)

344Path.GetFileName(i.PackagePath).Equals(fileName, StringComparison.OrdinalIgnoreCase) && 450return !String.IsNullOrWhiteSpace(path) && Path.GetExtension(path).Equals(".dll", StringComparison.OrdinalIgnoreCase);

CreateTrimDependencyGroupsTests.cs (4)

231f.ItemSpec.Equals("System.Collections.Immutable", StringComparison.OrdinalIgnoreCase)) 237f.ItemSpec.Equals("System.Collections.Immutable", StringComparison.OrdinalIgnoreCase)) 243f.ItemSpec.Equals("System.Collections.Immutable", StringComparison.OrdinalIgnoreCase)) 249f.ItemSpec.Equals("System.Collections.Immutable", StringComparison.OrdinalIgnoreCase))

ChooseBestP2PTargetFrameworkTask.cs (1)

119nugetFramework = targetFrameworkMoniker.Contains(',', System.StringComparison.Ordinal)

OptProf\GenerateTrainingPropsFile.cs (1)

44if (hasDropName && !ProductDropName.StartsWith(ProductDropNamePrefix, StringComparison.Ordinal))

OptProf\GetRunSettingsSessionConfiguration.cs (2)

82if (!dropUrl.StartsWith(prefix, StringComparison.Ordinal)) 101if (!vsDropName.StartsWith(prefix, StringComparison.Ordinal))

OptProf\IbcEntry.cs (1)

71=> path.StartsWith(prefix, StringComparison.OrdinalIgnoreCase) ? replacement + path.Substring(prefix.Length) : path;

Extensions.cs (1)

26if (string.Equals(metadataName, name, StringComparison.OrdinalIgnoreCase))

Msi\MsiBase.wix.cs (1)

81(!string.IsNullOrWhiteSpace(Metadata.Authors) && (Metadata.Authors.IndexOf("Microsoft", StringComparison.OrdinalIgnoreCase) < 0)) ?

Msi\WorkloadPackGroupMsi.wix.cs (1)

169if (!subdir.Id.Equals(id, StringComparison.Ordinal))

StringExtensions.cs (1)

29public static string TrimStart(this string str, string trimString, StringComparison comparisonType)

Analyzers\MembersMustExistAnalyzer.cs (1)

48var additionalAnalyzerFiles = context.Options.AdditionalFiles.Where(af => af.Path.IndexOf(s_analyzerName, 0, StringComparison.OrdinalIgnoreCase) >= 0);

Analyzers\PinvokeAnalyzer.cs (5)

30_allowedPinvokeFile = obj.Options.AdditionalFiles.FirstOrDefault(f => Path.GetFileName(f.Path).IndexOf("PinvokeAnalyzer_", StringComparison.OrdinalIgnoreCase) >= 0); 31_exceptionFile = obj.Options.AdditionalFiles.FirstOrDefault(f => Path.GetFileName(f.Path).IndexOf("PinvokeAnalyzerExceptionList.analyzerdata", StringComparison.OrdinalIgnoreCase) >= 0); 113if (AllowedPinvokes[methodName].Equals(moduleName, StringComparison.OrdinalIgnoreCase)) 130return (ExceptionPinvokes.ContainsKey(methodName) && ExceptionPinvokes[methodName].Equals(moduleName, StringComparison.OrdinalIgnoreCase)); 142if (data.ModuleName.Equals("QCall", StringComparison.OrdinalIgnoreCase)) return;

GenAPITask.cs (3)

427if (langVersionValue.Equals("default", StringComparison.OrdinalIgnoreCase)) 431else if (langVersionValue.Equals("latest", StringComparison.OrdinalIgnoreCase)) 435else if (langVersionValue.Equals("preview", StringComparison.OrdinalIgnoreCase))

JobDefinition.cs (2)

313if (string.Equals(reason, "PullRequest", StringComparison.OrdinalIgnoreCase)) 319if (string.Equals(teamProject, "internal", StringComparison.OrdinalIgnoreCase))

FindDotNetCliPackage.cs (6)

285if (string.Equals(Channel, "lts", StringComparison.OrdinalIgnoreCase)) 289else if (string.Equals(Channel, "current", StringComparison.OrdinalIgnoreCase)) 298if (string.Equals(Version, "latest", StringComparison.OrdinalIgnoreCase)) 303if (string.Equals(PackageType, "sdk", StringComparison.OrdinalIgnoreCase)) 307else if (string.Equals(PackageType, "aspnetcore-runtime", StringComparison.OrdinalIgnoreCase)) 311else if (string.Equals(PackageType, "runtime", StringComparison.OrdinalIgnoreCase))

src\NuGetUtils.cs (1)

23return dirName == "/" && fileName.EndsWith(".nuspec", StringComparison.OrdinalIgnoreCase);

src\NuGetVersionUpdater.cs (1)

273if (string.Equals(name?.Value, "DotnetTool", StringComparison.OrdinalIgnoreCase))

RemoteExecutor.cs (3)

65if (!IOPath.GetFileName(HostRunner).Equals(hostName, StringComparison.OrdinalIgnoreCase)) 84else if (RuntimeInformation.FrameworkDescription.StartsWith(".NET Framework", StringComparison.OrdinalIgnoreCase)) 95Environment.Version.Major >= 5 || RuntimeInformation.FrameworkDescription.StartsWith(".NET Core", StringComparison.OrdinalIgnoreCase);

src\CreateFrameworkListFile.cs (3)

92.EndsWith(".resources.dll", StringComparison.OrdinalIgnoreCase) 96(f.Filename.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) || f.IsNative || f.IsPgoData)) 147if (pathParts.Length < 3 || !pathParts[1].Equals("dotnet", StringComparison.Ordinal) || pathParts.Length > 4)

src\ValidateFileVersions.cs (3)

25if (file.GetMetadata("IsSymbolFile").Equals("true", StringComparison.OrdinalIgnoreCase)) 76p.Key.EndsWith(".exe", StringComparison.OrdinalIgnoreCase) || 77p.Key.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))

Verification\AuthentiCode.cs (6)

198if (String.Equals(unsignedAttribute.Oid.Value, WinCrypt.szOID_RSA_counterSign, StringComparison.OrdinalIgnoreCase)) 204if (String.Equals(signedAttribute.Oid.Value, WinCrypt.szOID_RSA_signingTime, StringComparison.OrdinalIgnoreCase)) 222else if (String.Equals(unsignedAttribute.Oid.Value, WinCrypt.szOID_RFC3161_counterSign, StringComparison.OrdinalIgnoreCase)) 226else if (String.Equals(unsignedAttribute.Oid.Value, WinCrypt.szOID_NESTED_SIGNATURE, StringComparison.OrdinalIgnoreCase)) 236if (String.Equals(nestedUnsignedAttribute.Oid.Value, WinCrypt.szOID_RFC3161_counterSign, StringComparison.OrdinalIgnoreCase)) 258if (String.Equals(rfc3161Message.ContentInfo.ContentType.Value, WinCrypt.szOID_TIMESTAMP_TOKEN, StringComparison.OrdinalIgnoreCase))

Verification\Exclusions.cs (1)

197return String.Equals(pattern, value, StringComparison.OrdinalIgnoreCase);

Verification\Jar\JarIndividualEntry.cs (1)

74string digestAttributeKey = Attributes.Keys.FirstOrDefault(key => key.EndsWith("-Digest", StringComparison.OrdinalIgnoreCase));

Verification\Jar\JarManifestFileBase.cs (1)

95ZipArchiveEntry manifestArchiveEntry = archive.Entries.First(a => String.Equals(a.FullName, ManifestPath, StringComparison.OrdinalIgnoreCase));

Verification\Jar\JarUtils.cs (1)

66int digestIndex = attribute.IndexOf(suffix, StringComparison.OrdinalIgnoreCase);

Verification\SignatureVerificationManager.cs (3)

248if (zipArchive.Entries.Any(z => String.Equals(Path.GetExtension(z.FullName), "nuspec", StringComparison.OrdinalIgnoreCase))) 253else if (zipArchive.Entries.Any(z => String.Equals(Path.GetExtension(z.FullName), "vsixmanifest", StringComparison.OrdinalIgnoreCase))) 258else if (zipArchive.Entries.Any(z => String.Equals(z.FullName, "META-INF/MANIFEST.MF", StringComparison.OrdinalIgnoreCase)))

src\Common\Internal\AssemblyResolution.cs (1)

28if (!name.Name.Equals("System.Collections.Immutable", StringComparison.OrdinalIgnoreCase))

src\BatchSignUtil.cs (2)

683private static bool IsVsixCertificate(string certificate) => certificate.StartsWith("Vsix", StringComparison.OrdinalIgnoreCase); 685private static bool IsLinuxSignCertificate(string certificate) => certificate.StartsWith("LinuxSign", StringComparison.OrdinalIgnoreCase);

src\Configuration.cs (6)

211var wixPack = _wixPacks.SingleOrDefault(w => w.Moniker.Equals(file.FileName, StringComparison.OrdinalIgnoreCase)); 316extension = _fileExtensionSignInfo.OrderByDescending(o => o.Key.Length).FirstOrDefault(f => file.FileName.EndsWith(f.Key, StringComparison.OrdinalIgnoreCase)).Key ?? extension; 454if (SignToolConstants.IgnoreFileCertificateSentinel.Equals(explicitCertificateName, StringComparison.OrdinalIgnoreCase)) 485if (signInfo.Certificate != null && signInfo.Certificate.Equals("BreakingSignatureChange", StringComparison.OrdinalIgnoreCase)) 611=> name.Equals("3PartyDual", StringComparison.OrdinalIgnoreCase) || 612name.Equals("3PartySHA2", StringComparison.OrdinalIgnoreCase);

src\ExplicitCertificateKey.cs (1)

35string.Equals(PublicKeyToken, other.PublicKeyToken, StringComparison.OrdinalIgnoreCase) &&

src\FileSignInfo.cs (18)

src\SignInfo.cs (1)

52public bool ShouldLocallyStrongNameSign => ShouldStrongName && StrongName.EndsWith(".snk", StringComparison.OrdinalIgnoreCase);

src\SignToolTask.cs (4)

438SignInfo signInfo = certificate.Equals(SignToolConstants.IgnoreFileCertificateSentinel, StringComparison.InvariantCultureIgnoreCase) ? 491if (SignToolConstants.IgnoreFileCertificateSentinel.Equals(certificateName, StringComparison.OrdinalIgnoreCase) && 492SignToolConstants.IgnoreFileCertificateSentinel.Equals(strongName, StringComparison.OrdinalIgnoreCase)) 498var signInfo = SignToolConstants.IgnoreFileCertificateSentinel.Equals(strongName, StringComparison.OrdinalIgnoreCase)

src\VerifySignatures.cs (2)

130return File.ReadLines(filePath).Any(line => line.IndexOf("# SIG # Begin Signature Block", StringComparison.OrdinalIgnoreCase) >= 0) 173return archive.GetFiles().Any(f => f.StartsWith("package/services/digital-signature/", StringComparison.OrdinalIgnoreCase)) ?

src\WixPackInfo.cs (1)

42return Path.GetFileName(path).EndsWith(WixPackExtension, StringComparison.OrdinalIgnoreCase);

src\UsageReport\Usage.cs (4)

61.Where(rid => identity.Id.StartsWith($"runtime.{rid}.", StringComparison.Ordinal)) 72if (PackageIdentity.Id.StartsWith(prefix, StringComparison.Ordinal)) 101string.Equals(AssetsFile, other.AssetsFile, StringComparison.Ordinal) && 102string.Equals(RuntimePackageRid, other.RuntimePackageRid, StringComparison.Ordinal);

src\UsageReport\WritePackageUsageData.cs (1)

90.Where(dir => !dir.StartsWith(RootDir, StringComparison.Ordinal))

src\UsageReport\WriteUsageReports.cs (1)

122if (p.Name.Equals(pvpIdent, StringComparison.OrdinalIgnoreCase))

src\Common\Internal\AssemblyResolution.cs (1)

28if (!name.Name.Equals("System.Collections.Immutable", StringComparison.OrdinalIgnoreCase))

Tasks\GatherTranslatedSource.cs (1)

28bool preserveFileName = string.Equals(xlf.GetMetadata(MetadataKey.XlfPreserveFileName), "true", StringComparison.OrdinalIgnoreCase);

Tasks\GatherXlf.cs (1)

53bool preserveFileName = string.Equals(source.GetMetadata(MetadataKey.XlfPreserveFileName), "true", StringComparison.OrdinalIgnoreCase);

Tasks\XlfTask.cs (6)

37if (format.Equals("Resx", StringComparison.OrdinalIgnoreCase)) 41else if (format.Equals("Unstructured", StringComparison.OrdinalIgnoreCase)) 45else if (format.Equals("Vsct", StringComparison.OrdinalIgnoreCase)) 49else if (format.Equals("XamlRule", StringComparison.OrdinalIgnoreCase)) 53else if (format.Equals("Json", StringComparison.OrdinalIgnoreCase)) 97if (extension.Equals(".resx", StringComparison.OrdinalIgnoreCase))

MemoryAssertsTests.cs (12)

SpanAssertsTests.cs (12)

StringAssertsTests.cs (36)

src\Microsoft.DotNet.XUnitExtensions.Shared\CoreClrConfigurationDetection.cs (13)

src\Microsoft.DotNet.XUnitExtensions.Shared\DiscovererHelpers.cs (2)

17public static bool IsRunningOnNetCoreApp { get; } = (Environment.Version.Major >= 5 || !RuntimeInformation.FrameworkDescription.StartsWith(".NET Framework", StringComparison.OrdinalIgnoreCase)); 18public static bool IsRunningOnNetFramework { get; } = RuntimeInformation.FrameworkDescription.StartsWith(".NET Framework", StringComparison.OrdinalIgnoreCase);

src\Microsoft.DotNet.XUnitExtensions.Shared\CoreClrConfigurationDetection.cs (13)

src\Microsoft.DotNet.XUnitExtensions.Shared\DiscovererHelpers.cs (2)

17public static bool IsRunningOnNetCoreApp { get; } = (Environment.Version.Major >= 5 || !RuntimeInformation.FrameworkDescription.StartsWith(".NET Framework", StringComparison.OrdinalIgnoreCase)); 18public static bool IsRunningOnNetFramework { get; } = RuntimeInformation.FrameworkDescription.StartsWith(".NET Framework", StringComparison.OrdinalIgnoreCase);

Functions\AIFunctionFactory.cs (1)

830name.EndsWith(AsyncSuffix, StringComparison.Ordinal) &&

ChatCompletion\ChatRole.cs (1)

81=> string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

ChatCompletion\RequiredChatToolMode.cs (1)

61RequiredFunctionName?.GetHashCode(StringComparison.Ordinal) ??

Contents\DataContent.cs (1)

83if (!uri.StartsWith(DataUriParser.Scheme, StringComparison.OrdinalIgnoreCase))

Contents\DataUriParser.cs (3)

29if (!dataUri.Span.StartsWith(Scheme.AsSpan(), StringComparison.OrdinalIgnoreCase)) 51if (metadata.Span.EndsWith(";base64".AsSpan(), StringComparison.OrdinalIgnoreCase)) 137return span.Equals(topLevelMediaType.AsSpan(), StringComparison.OrdinalIgnoreCase);

SpeechToText\SpeechToTextResponseUpdateKind.cs (1)

83=> string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

src\LegacySupport\StringHash\StringHash.cs (7)

15public static int GetHashCode(this string s, StringComparison comparisonType) 19StringComparison.CurrentCulture => StringComparer.CurrentCulture, 20StringComparison.CurrentCultureIgnoreCase => StringComparer.CurrentCultureIgnoreCase, 21StringComparison.InvariantCulture => StringComparer.InvariantCulture, 22StringComparison.InvariantCultureIgnoreCase => StringComparer.InvariantCultureIgnoreCase, 23StringComparison.Ordinal => StringComparer.Ordinal, 24StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase,

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

414public bool Equals(ParameterLookupKey other) => Type == other.Type && string.Equals(Name, other.Name, StringComparison.OrdinalIgnoreCase);

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

265Debug.Assert(refUri is "#" || refUri.StartsWith("#/", StringComparison.Ordinal), $"Expected {nameof(refUri)} to be either # or start with #/, got {refUri}");

AzureAIInferenceChatClient.cs (2)

530if (dataContent.MediaType.Equals("audio/mpeg", StringComparison.OrdinalIgnoreCase)) 534else if (dataContent.MediaType.Equals("audio/wav", StringComparison.OrdinalIgnoreCase))

Formats\Html\HtmlReportWriter.cs (1)

92int start = all.IndexOf(SearchString, StringComparison.Ordinal);

Utilities\IterationNameComparer.cs (1)

28return string.Compare(first, second, StringComparison.Ordinal);

Storage\AzureStorageResponseCache.cs (1)

206if (pathItem.Name.EndsWith($"/{EntryFileName}", StringComparison.Ordinal))

AIContentExtensions.cs (4)

21mediaType.Equals("image/jpeg", StringComparison.OrdinalIgnoreCase) || 22mediaType.Equals("image/jpg", StringComparison.OrdinalIgnoreCase) || 23mediaType.Equals("image/png", StringComparison.OrdinalIgnoreCase) || 24mediaType.Equals("image/gif", StringComparison.OrdinalIgnoreCase);

ContentSafetyService.cs (1)

278string.Equals(supportedCapability, capability, StringComparison.Ordinal))

ChatClientIntegrationTests.cs (5)

52Assert.Contains("whale", response.Text, StringComparison.OrdinalIgnoreCase); 104Assert.Contains("one small step", responseText, StringComparison.OrdinalIgnoreCase); 105Assert.Contains("one giant leap", responseText, StringComparison.OrdinalIgnoreCase); 183Assert.True(response.Text.IndexOf("net", StringComparison.OrdinalIgnoreCase) >= 0, response.Text); 201Assert.True(response.Text.IndexOf("hello", StringComparison.OrdinalIgnoreCase) >= 0, response.Text);

PromptBasedFunctionCallingChatClient.cs (2)

86&& content.IndexOf("<tool_call_json>", StringComparison.Ordinal) is int startPos 101var endPos = toolCall.IndexOf("</tool", StringComparison.Ordinal);

ReducingChatClientTests.cs (2)

34m => Assert.StartsWith("Golden retrievers are quite active", m.Text, StringComparison.Ordinal), 35m => Assert.StartsWith("Are they good with kids?", m.Text, StringComparison.Ordinal));

SpeechToTextClientIntegrationTests.cs (3)

41Assert.Contains("gym", response.Text, StringComparison.OrdinalIgnoreCase); 58Assert.Contains("finally", responseText, StringComparison.OrdinalIgnoreCase); 59Assert.Contains("gym", responseText, StringComparison.OrdinalIgnoreCase);

src\LegacySupport\StringHash\StringHash.cs (7)

15public static int GetHashCode(this string s, StringComparison comparisonType) 19StringComparison.CurrentCulture => StringComparer.CurrentCulture, 20StringComparison.CurrentCultureIgnoreCase => StringComparer.CurrentCultureIgnoreCase, 21StringComparison.InvariantCulture => StringComparer.InvariantCulture, 22StringComparison.InvariantCultureIgnoreCase => StringComparer.InvariantCultureIgnoreCase, 23StringComparison.Ordinal => StringComparer.Ordinal, 24StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase,

OpenAIChatClient.cs (3)

212if (dataContent.MediaType.Equals("audio/mpeg", StringComparison.OrdinalIgnoreCase)) 216else if (dataContent.MediaType.Equals("audio/wav", StringComparison.OrdinalIgnoreCase)) 223case DataContent dataContent when dataContent.MediaType.StartsWith("application/pdf", StringComparison.OrdinalIgnoreCase):

OpenAIResponseChatClient.cs (1)

591case DataContent dataContent when dataContent.MediaType.StartsWith("application/pdf", StringComparison.OrdinalIgnoreCase):

IntegrationTestHelpers.cs (1)

24if (string.Equals(mode, "AzureOpenAI", StringComparison.OrdinalIgnoreCase))

AIChatWebExecutionTests.cs (2)

132if (string.Equals(name, options[i], StringComparison.Ordinal) && 133string.Equals(value, options[i + 1], StringComparison.Ordinal))

Infrastructure\Project.cs (1)

28else if (!string.Equals(value, _startupProjectRelativePath, StringComparison.Ordinal))

Functions\AIFunctionFactoryTest.cs (1)

92Assert.DoesNotContain("cancellationToken", func.JsonSchema.ToString(), StringComparison.OrdinalIgnoreCase);

GetOpenApiReferenceMetadata.cs (1)

89StringComparison.OrdinalIgnoreCase);

GetOpenApiReferenceMetadataTest.cs (3)

282Assert.Contains(error1, buildEngine.Log, StringComparison.OrdinalIgnoreCase); 283Assert.Contains(error2, buildEngine.Log, StringComparison.OrdinalIgnoreCase); 328Assert.Contains(error, buildEngine.Log, StringComparison.OrdinalIgnoreCase);

src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

67if (string.Equals(expectedFileName, mainModuleFileName, StringComparison.OrdinalIgnoreCase))

GetDocumentTests.cs (1)

123var documentNames = Directory.GetFiles(outputPath.FullName).Where(documentName => documentName.EndsWith(".json", StringComparison.Ordinal)).ToList();

Classification\DataClassificationSet.cs (2)

117var result = string.Compare(x.TaxonomyName, y.TaxonomyName, StringComparison.Ordinal); 118return result != 0 ? result : string.Compare(x.Value, y.Value, StringComparison.Ordinal);

ConfigurationKeyComparer.cs (1)

84result = a.CompareTo(b, StringComparison.OrdinalIgnoreCase);

ConfigurationProvider.cs (1)

81kv.Key.StartsWith(parentPath, StringComparison.OrdinalIgnoreCase) &&

EnvironmentVariablesConfigurationProvider.cs (5)

74if (key.StartsWith(MySqlServerPrefix, StringComparison.OrdinalIgnoreCase)) 78else if (key.StartsWith(SqlAzureServerPrefix, StringComparison.OrdinalIgnoreCase)) 82else if (key.StartsWith(SqlServerPrefix, StringComparison.OrdinalIgnoreCase)) 86else if (key.StartsWith(CustomConnectionStringPrefix, StringComparison.OrdinalIgnoreCase)) 118if (normalizedKey.StartsWith(_normalizedPrefix, StringComparison.OrdinalIgnoreCase))

KeyPerFileConfigurationProvider.cs (1)

46=> value.EndsWith(Environment.NewLine, StringComparison.Ordinal)

KeyPerFileConfigurationSource.cs (1)

18=> IgnoreCondition = s => IgnorePrefix != null && s.StartsWith(IgnorePrefix, StringComparison.Ordinal);

XmlStreamConfigurationProvider.cs (2)

97if (string.Equals(parent.SingleChild.SiblingName, element.SiblingName, StringComparison.OrdinalIgnoreCase)) 237if (string.Equals(reader.LocalName, Consts.NameAttributeKey, StringComparison.OrdinalIgnoreCase))

Resolution\AppBaseCompilationAssemblyResolver.cs (5)

48bool isProject = string.Equals(library.Type, "project", StringComparison.OrdinalIgnoreCase) || 49string.Equals(library.Type, "msbuildproject", StringComparison.OrdinalIgnoreCase); 51bool isPackage = string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase); 52bool isReferenceAssembly = string.Equals(library.Type, "referenceassembly", StringComparison.OrdinalIgnoreCase); 56!string.Equals(library.Type, "reference", StringComparison.OrdinalIgnoreCase))

Resolution\PackageCompilationAssemblyResolver.cs (1)

74!string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase))

Resolution\ReferenceAssemblyPathResolver.cs (1)

48if (!string.Equals(library.Type, "referenceassembly", StringComparison.OrdinalIgnoreCase))

Metrics\Configuration\MetricsConfigureOptions.cs (5)

30if (configurationSection.Key.Equals(EnabledMetricsKey, StringComparison.OrdinalIgnoreCase)) 35else if (configurationSection.Key.Equals(EnabledGlobalMetricsKey, StringComparison.OrdinalIgnoreCase)) 40else if (configurationSection.Key.Equals(EnabledLocalMetricsKey, StringComparison.OrdinalIgnoreCase)) 83if (string.Equals(DefaultKey, meterName, StringComparison.OrdinalIgnoreCase)) 102if (string.Equals(DefaultKey, instrumentName, StringComparison.OrdinalIgnoreCase))

Metrics\ListenerSubscription.cs (4)

149&& !string.Equals(rule.ListenerName, listenerName, StringComparison.OrdinalIgnoreCase)) 156&& !string.Equals(rule.InstrumentName, instrument.Name, StringComparison.OrdinalIgnoreCase)) 194if (!instrument.Meter.Name.AsSpan().StartsWith(prefix, StringComparison.OrdinalIgnoreCase) || 195!instrument.Meter.Name.AsSpan().EndsWith(suffix, StringComparison.OrdinalIgnoreCase))

ExceptionSummary.cs (6)

68ExceptionType.GetHashCode(StringComparison.Ordinal), 69Description.GetHashCode(StringComparison.Ordinal), 70AdditionalDetails.GetHashCode(StringComparison.Ordinal)); 100return other.ExceptionType.Equals(ExceptionType, StringComparison.Ordinal) 101&& other.Description.Equals(Description, StringComparison.Ordinal) 102&& other.AdditionalDetails.Equals(AdditionalDetails, StringComparison.Ordinal);

src\LegacySupport\StringHash\StringHash.cs (7)

15public static int GetHashCode(this string s, StringComparison comparisonType) 19StringComparison.CurrentCulture => StringComparer.CurrentCulture, 20StringComparison.CurrentCultureIgnoreCase => StringComparer.CurrentCultureIgnoreCase, 21StringComparison.InvariantCulture => StringComparer.InvariantCulture, 22StringComparison.InvariantCultureIgnoreCase => StringComparer.InvariantCultureIgnoreCase, 23StringComparison.Ordinal => StringComparer.Ordinal, 24StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase,

Linux\LinuxUtilizationParserCgroupV2.cs (3)

290if (memoryBuffer.Equals("max\n", StringComparison.InvariantCulture)) 639if (quotaBuffer.StartsWith("max", StringComparison.InvariantCulture)) 680if (content.StartsWith("max", StringComparison.InvariantCulture))

Linux\Network\LinuxNetworkUtilizationParser.cs (1)

151if (!firstLine.StartsWith(Sl, StringComparison.Ordinal))

Windows\Disk\WindowsDiskMetrics.cs (1)

80.Where(instanceName => !instanceName.Equals("_Total", StringComparison.OrdinalIgnoreCase))

Linux\Resources\HardcodedValueFileSystem.cs (1)

39.Where(x => x.StartsWith(directory, StringComparison.OrdinalIgnoreCase))

ResourceMonitoringServiceTests.cs (2)

263Assert.Contains(ProviderUnableToGatherData, logger.Collector.LatestRecord.Message, StringComparison.OrdinalIgnoreCase); 291Assert.Contains(_publisherUnableToPublishErrorMessage, logger.Collector.LatestRecord.Message, StringComparison.OrdinalIgnoreCase);

EmbeddedFileProvider.cs (3)

93if (subpath.StartsWith("/", StringComparison.Ordinal)) 146if (subpath.Length != 0 && !string.Equals(subpath, "/", StringComparison.Ordinal)) 158if (resourceName.StartsWith(_baseNamespace, StringComparison.Ordinal))

Manifest\ManifestDirectory.cs (3)

25if (segment.Equals(".", StringComparison.Ordinal)) 30if (segment.Equals("..", StringComparison.Ordinal)) 37if (segment.Equals(child.Name, StringComparison.OrdinalIgnoreCase))

Manifest\ManifestParser.cs (4)

41if (!string.Equals("1.0", version, StringComparison.Ordinal)) 70if (string.Equals(entriesList[i].Name, entriesList[j].Name, StringComparison.OrdinalIgnoreCase)) 89if (string.Equals(element.Name.LocalName, "File", StringComparison.Ordinal)) 97if (string.Equals(element.Name.LocalName, "Directory", StringComparison.Ordinal))

FileInfoComparer.cs (2)

28string.Equals(x.Name, y.Name, StringComparison.Ordinal) && 29string.Equals(x.PhysicalPath, y.PhysicalPath, StringComparison.Ordinal);

Internal\FileSystemInfoHelper.cs (1)

18else if (fileSystemInfo.Name.StartsWith(".", StringComparison.Ordinal) && (filters & ExclusionFilters.DotPrefixed) != 0)

PhysicalFileProvider.cs (3)

191bool pollForChanges = string.Equals(environmentValue, "1", StringComparison.Ordinal) || 192string.Equals(environmentValue, "true", StringComparison.OrdinalIgnoreCase); 255return fullPath.StartsWith(Root, StringComparison.OrdinalIgnoreCase);

PhysicalFilesWatcher.cs (1)

215var matcher = new Matcher(StringComparison.OrdinalIgnoreCase);

PollingWildCardChangeToken.cs (1)

58_matcher = new Matcher(StringComparison.OrdinalIgnoreCase);

Abstractions\DirectoryInfoWrapper.cs (1)

72bool isParentPath = string.Equals(name, "..", StringComparison.Ordinal);

FilePatternMatch.cs (2)

53return string.Equals(other.Path, Path, StringComparison.OrdinalIgnoreCase) && 54string.Equals(other.Stem, Stem, StringComparison.OrdinalIgnoreCase);

InMemoryDirectoryInfo.cs (2)

124return filePath.StartsWith(rootDir, StringComparison.Ordinal) && 132if (string.Equals(path, "..", StringComparison.Ordinal))

Internal\MatcherContext.cs (2)

30private readonly StringComparison _comparisonType; 36StringComparison comparison)

Internal\PathSegments\LiteralPathSegment.cs (2)

12private readonly StringComparison _comparisonType; 16public LiteralPathSegment(string value, StringComparison comparisonType)

Internal\PathSegments\ParentPathSegment.cs (1)

16return string.Equals(LiteralParent, value, StringComparison.Ordinal);

Internal\PathSegments\WildcardPathSegment.cs (5)

14string.Empty, new List<string>(), string.Empty, StringComparison.OrdinalIgnoreCase); 16private readonly StringComparison _comparisonType; 18public WildcardPathSegment(string beginsWith, List<string> contains, string endsWith, StringComparison comparisonType) 26StringComparison.OrdinalIgnoreCase or StringComparison.Ordinal => comparisonType,

Internal\Patterns\PatternBuilder.cs (3)

18ComparisonType = StringComparison.OrdinalIgnoreCase; 21public PatternBuilder(StringComparison comparisonType) 26public StringComparison ComparisonType { get; }

Matcher.cs (4)

102private readonly StringComparison _comparison; 108: this(StringComparison.OrdinalIgnoreCase) 115/// <param name="comparisonType">The <see cref="StringComparison" /> to use</param> 116public Matcher(StringComparison comparisonType)

Util\StringComparisonHelper.cs (7)

10public static StringComparer GetStringComparer(StringComparison comparisonType) => comparisonType switch 12StringComparison.CurrentCulture => StringComparer.CurrentCulture, 13StringComparison.CurrentCultureIgnoreCase => StringComparer.CurrentCultureIgnoreCase, 14StringComparison.Ordinal => StringComparer.Ordinal, 15StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase, 16StringComparison.InvariantCulture => StringComparer.InvariantCulture, 17StringComparison.InvariantCultureIgnoreCase => StringComparer.InvariantCultureIgnoreCase,

HostApplicationBuilder.cs (4)

288if (!string.Equals(previousApplicationName, config[HostDefaults.ApplicationKey], StringComparison.OrdinalIgnoreCase)) 292if (!string.Equals(previousEnvironment, config[HostDefaults.EnvironmentKey], StringComparison.OrdinalIgnoreCase)) 299if (!string.Equals(previousContentRootConfig, currentContentRootConfig, StringComparison.OrdinalIgnoreCase) && 300!string.Equals(previousContentRootPath, HostBuilder.ResolveContentRootPath(currentContentRootConfig, AppContext.BaseDirectory), StringComparison.OrdinalIgnoreCase))

HostingHostBuilderExtensions.cs (1)

227!string.Equals(cwd, Environment.SystemDirectory, StringComparison.OrdinalIgnoreCase))

HostEnvironmentEnvExtensions.cs (1)

64StringComparison.OrdinalIgnoreCase);

HostingEnvironmentExtensions.cs (1)

65StringComparison.OrdinalIgnoreCase);

WindowsServiceHelpers.cs (1)

46return string.Equals("services", parent.ProcessName, StringComparison.OrdinalIgnoreCase);

Http\DownstreamDependencyMetadataManager.cs (2)

111else if (requestRouteAsSpan.StartsWith("//".AsSpan(), StringComparison.OrdinalIgnoreCase)) 364if (requestRouteAsSpan.StartsWith("//".AsSpan(), StringComparison.OrdinalIgnoreCase))

Logging\Internal\MediaTypeCollectionExtensions.cs (4)

29if (sample!.StartsWith(Text, StringComparison.OrdinalIgnoreCase)) 34if (sample.StartsWith(Application, StringComparison.OrdinalIgnoreCase) 35&& (sample.EndsWith(Json, StringComparison.OrdinalIgnoreCase) 36|| sample.EndsWith(Xml, StringComparison.OrdinalIgnoreCase)))

ResourceManagerStringLocalizerFactory.cs (1)

239if (name.StartsWith(prefix, StringComparison.Ordinal))

LoggerRuleSelector.cs (2)

73if (!category.AsSpan().StartsWith(prefix, StringComparison.OrdinalIgnoreCase) || 74!category.AsSpan().EndsWith(suffix, StringComparison.OrdinalIgnoreCase))

LoggerFilterConfigureOptions.cs (2)

37if (configurationSection.Key.Equals(LogLevelKey, StringComparison.OrdinalIgnoreCase)) 62if (category.Equals(DefaultCategory, StringComparison.OrdinalIgnoreCase))

ConsoleLoggerProvider.cs (1)

72if (envVar is not null && (envVar == "1" || envVar.Equals("true", StringComparison.OrdinalIgnoreCase)))

src\libraries\Common\src\System\Console\ConsoleUtils.cs (1)

42enabled = envVar is not null && (envVar == "1" || envVar.Equals("true", StringComparison.OrdinalIgnoreCase));

LoggingEventSource.cs (1)

427if (ruleStrings.Length > 0 && ruleStrings[0].Equals(UseAppFilters, StringComparison.OrdinalIgnoreCase))

LoggerMessageGenerator.Emitter.cs (2)

65if (!template.Equals(parameter, StringComparison.OrdinalIgnoreCase)) 224if (template.Equals(parameter, StringComparison.OrdinalIgnoreCase))

LoggerMessageGenerator.Parser.cs (9)

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (3)

156var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;

OptionsBuilderConfigurationExtensions.cs (1)

75IConfiguration section = string.Equals("", configSectionPath, StringComparison.OrdinalIgnoreCase)

Parser.cs (1)

284&& !baseType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat).StartsWith("global::System.", StringComparison.Ordinal))

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (3)

156var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;

SymbolLoader.cs (2)

53if (!containingAssemblyName.Equals("System.Private.CoreLib", System.StringComparison.OrdinalIgnoreCase) && 54!containingAssemblyName.Equals("System.Runtime", System.StringComparison.OrdinalIgnoreCase))

StringSegment.cs (10)

StringSegmentComparer.cs (4)

18= new StringSegmentComparer(StringComparison.Ordinal, StringComparer.Ordinal); 24= new StringSegmentComparer(StringComparison.OrdinalIgnoreCase, StringComparer.OrdinalIgnoreCase); 26private StringSegmentComparer(StringComparison comparison, StringComparer comparer) 32private StringComparison Comparison { get; }

StringValues.cs (2)

319if (string.Equals(values[i], item, StringComparison.Ordinal)) 330return string.Equals(Unsafe.As<string>(value), item, StringComparison.Ordinal) ? 0 : -1;

PassThrough\PassThroughServiceEndpointProviderFactory.cs (1)

31if ((serviceName.Contains("://", StringComparison.Ordinal) || !Uri.TryCreate($"fakescheme://{serviceName}", default, out var uri)) && !Uri.TryCreate(serviceName, default, out uri))

ServiceDiscoveryOptions.cs (1)

52if (string.Equals(s, allowed, StringComparison.OrdinalIgnoreCase))

ServiceEndpointQuery.cs (1)

41if (!input.Contains("://", StringComparison.InvariantCulture)

Buffering\GlobalLogBufferingOptionsCustomValidator.cs (1)

24int wildcardIndex = rule.CategoryName.IndexOf(WildcardChar, StringComparison.Ordinal);

Buffering\LogBufferingFilterRuleSelector.cs (2)

158if (!category.AsSpan().StartsWith(prefix, StringComparison.OrdinalIgnoreCase) || 159!category.AsSpan().EndsWith(suffix, StringComparison.OrdinalIgnoreCase))

Http\Segment.cs (2)

77parameter.Equals(ControllerParameter, StringComparison.OrdinalIgnoreCase) || 78parameter.Equals(ActionParameter, StringComparison.OrdinalIgnoreCase);

Logging\ExtendedLogger.cs (1)

192trace = trace.Replace(Environment.NewLine, Environment.NewLine + indentStr + " ", StringComparison.Ordinal).Trim(' ');

Logging\Import\LoggerRuleSelector.cs (2)

78if (!category.AsSpan().StartsWith(prefix, StringComparison.OrdinalIgnoreCase) || 79!category.AsSpan().EndsWith(suffix, StringComparison.OrdinalIgnoreCase))

Sampling\LogSamplingRuleSelector.cs (2)

59if (!category.AsSpan().StartsWith(prefix, StringComparison.OrdinalIgnoreCase) || 60!category.AsSpan().EndsWith(suffix, StringComparison.OrdinalIgnoreCase))

Latency\Checkpoint.cs (1)

59=> Elapsed == other.Elapsed && Frequency == other.Frequency && Name.Equals(other.Name, StringComparison.Ordinal);

Latency\Measure.cs (1)

51public bool Equals(Measure other) => Value == other.Value && Name.Equals(other.Name, StringComparison.Ordinal);

Parser.cs (2)

95if (result.StartsWith("global::", StringComparison.Ordinal)) 258if (name.EndsWith("Attribute", StringComparison.Ordinal))

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

145return string.Equals(generateFiles, bool.TrueString, StringComparison.OrdinalIgnoreCase);

test\Generators\Shared\RoslynTestUtils.cs (4)

117int start = text.IndexOf(seq, StringComparison.Ordinal); 125int end = text.IndexOf($"/*-{spanNum}*/", StringComparison.Ordinal); 191if (diagnostic.Id.Equals(f.Id, StringComparison.Ordinal)) 210if (diagnostic.Id.Equals(f.Id, StringComparison.Ordinal))

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

145return string.Equals(generateFiles, bool.TrueString, StringComparison.OrdinalIgnoreCase);

DiagDescriptorsTests.cs (1)

29Assert.EndsWith("/" + descriptor.Id, descriptor.HelpLinkUri, StringComparison.OrdinalIgnoreCase);

test\Generators\Shared\RoslynTestUtils.cs (4)

117int start = text.IndexOf(seq, StringComparison.Ordinal); 125int end = text.IndexOf($"/*-{spanNum}*/", StringComparison.Ordinal); 191if (diagnostic.Id.Equals(f.Id, StringComparison.Ordinal)) 210if (diagnostic.Id.Equals(f.Id, StringComparison.Ordinal))

Model\LoggingMethod.cs (2)

36if (templateName.Equals(p.TagName, StringComparison.OrdinalIgnoreCase)) 50if (lp.TagName.Equals(t, StringComparison.OrdinalIgnoreCase))

Parsing\Parser.cs (9)

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

145return string.Equals(generateFiles, bool.TrueString, StringComparison.OrdinalIgnoreCase);

src\Generators\Shared\RoslynExtensions.cs (3)

205var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;

DiagDescriptorsTests.cs (1)

30Assert.EndsWith("/" + descriptor.Id, descriptor.HelpLinkUri, StringComparison.OrdinalIgnoreCase);

test\Generators\Shared\RoslynTestUtils.cs (4)

117int start = text.IndexOf(seq, StringComparison.Ordinal); 125int end = text.IndexOf($"/*-{spanNum}*/", StringComparison.Ordinal); 191if (diagnostic.Id.Equals(f.Id, StringComparison.Ordinal)) 210if (diagnostic.Id.Equals(f.Id, StringComparison.Ordinal))

src\Generators\Microsoft.Gen.ComplianceReports\Parser.cs (2)

95if (result.StartsWith("global::", StringComparison.Ordinal)) 258if (name.EndsWith("Attribute", StringComparison.Ordinal))

src\Generators\Microsoft.Gen.Metrics\Parser.cs (1)

587if (!string.Equals(returnType.Name, returnType.ToString(), StringComparison.Ordinal))

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

145return string.Equals(generateFiles, bool.TrueString, StringComparison.OrdinalIgnoreCase);

test\Generators\Shared\RoslynTestUtils.cs (4)

117int start = text.IndexOf(seq, StringComparison.Ordinal); 125int end = text.IndexOf($"/*-{spanNum}*/", StringComparison.Ordinal); 191if (diagnostic.Id.Equals(f.Id, StringComparison.Ordinal)) 210if (diagnostic.Id.Equals(f.Id, StringComparison.Ordinal))

Parser.cs (1)

587if (!string.Equals(returnType.Name, returnType.ToString(), StringComparison.Ordinal))

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

145return string.Equals(generateFiles, bool.TrueString, StringComparison.OrdinalIgnoreCase);

src\Generators\Shared\RoslynExtensions.cs (3)

205var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;

DiagDescriptorsTests.cs (1)

29Assert.EndsWith("/" + descriptor.Id, descriptor.HelpLinkUri, StringComparison.OrdinalIgnoreCase);

test\Generators\Shared\RoslynTestUtils.cs (4)

117int start = text.IndexOf(seq, StringComparison.Ordinal); 125int end = text.IndexOf($"/*-{spanNum}*/", StringComparison.Ordinal); 191if (diagnostic.Id.Equals(f.Id, StringComparison.Ordinal)) 210if (diagnostic.Id.Equals(f.Id, StringComparison.Ordinal))

src\Generators\Microsoft.Gen.Metrics\Parser.cs (1)

587if (!string.Equals(returnType.Name, returnType.ToString(), StringComparison.Ordinal))

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

145return string.Equals(generateFiles, bool.TrueString, StringComparison.OrdinalIgnoreCase);

test\Generators\Shared\RoslynTestUtils.cs (4)

117int start = text.IndexOf(seq, StringComparison.Ordinal); 125int end = text.IndexOf($"/*-{spanNum}*/", StringComparison.Ordinal); 191if (diagnostic.Id.Equals(f.Id, StringComparison.Ordinal)) 210if (diagnostic.Id.Equals(f.Id, StringComparison.Ordinal))

ComInterfaceGenerator.cs (2)

244return typeName.Equals("hr", StringComparison.OrdinalIgnoreCase) 245|| typeName.Equals("hresult", StringComparison.OrdinalIgnoreCase);

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (3)

156var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;

src\libraries\System.Runtime.InteropServices\gen\Common\ConvertToSourceGeneratedInteropFixer.cs (2)

287return typeName.Equals("hr", StringComparison.OrdinalIgnoreCase) 288|| typeName.Equals("hresult", StringComparison.OrdinalIgnoreCase);

VirtualMethodPointerStubGenerator.cs (1)

306if (callConvSymbol.Name.StartsWith("CallConv", StringComparison.Ordinal))

JSManagedTypeInfo.cs (5)

120case INamedTypeSymbol { TypeArguments.Length: 1 } taskType when fullTypeName.StartsWith(Constants.TaskGlobal, StringComparison.Ordinal): 128case INamedTypeSymbol { TypeArguments.Length: 1 } spanType when fullTypeName.StartsWith(Constants.SpanGlobal, StringComparison.Ordinal): 136case INamedTypeSymbol { TypeArguments.Length: 1 } arraySegmentType when fullTypeName.StartsWith(Constants.ArraySegmentGlobal, StringComparison.Ordinal): 146case INamedTypeSymbol actionType when fullTypeName.StartsWith(Constants.ActionGlobal, StringComparison.Ordinal): 157case INamedTypeSymbol funcType when fullTypeName.StartsWith(Constants.FuncGlobal, StringComparison.Ordinal):

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (3)

156var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;

src\libraries\System.Runtime.InteropServices\gen\Common\ConvertToSourceGeneratedInteropFixer.cs (2)

287return typeName.Equals("hr", StringComparison.OrdinalIgnoreCase) 288|| typeName.Equals("hresult", StringComparison.OrdinalIgnoreCase);

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (3)

156var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (3)

156var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;

Infrastructure\DotNetDispatcher.cs (2)

176if (string.Equals(DisposeDotNetObjectReferenceMethodName, methodIdentifier, StringComparison.Ordinal)) 548return AssemblyName.Equals(other.AssemblyName, StringComparison.Ordinal);

Converters\EasingTypeConverter.cs (1)

50 left.Equals(right, StringComparison.OrdinalIgnoreCase);

Converters\FlexEnumsConverters.cs (17)

Extensions\StringExtensions.cs (2)

15 return toSearch.Contains(character, StringComparison.Ordinal); 24 return toSearch.IndexOf(character, StringComparison.Ordinal);

Fonts\FontFile.cs (2)

72 .Replace(" ", "", StringComparison.Ordinal) 81 if (fontFamilyName.EndsWith(extension, StringComparison.OrdinalIgnoreCase))

Fonts\FontRegistrar.cs (1)

108 if (name.EndsWith(searchName, StringComparison.CurrentCultureIgnoreCase))

Handlers\HybridWebView\HybridWebViewHandler.cs (2)

109 var indexOfPipe = rawMessage.IndexOf('|', StringComparison.Ordinal); 127 var indexOfPipeInContent = messageContent.IndexOf('|', StringComparison.Ordinal);

Handlers\HybridWebView\HybridWebViewQueryStringHelper.cs (1)

16 var indexOfQueryString = url.IndexOf('?', StringComparison.Ordinal);

Primitives\Font.cs (1)

90 return string.Equals(Family, other.Family, StringComparison.Ordinal)

Accelerator.cs (2)

57 text = text.Replace(modifierMask, "", StringComparison.Ordinal); 101 return _text.GetHashCode(StringComparison.Ordinal);

AnimatableKey.cs (3)

83 return Handle?.GetHashCode(StringComparison.Ordinal) ?? 0; 85 return ((target?.GetHashCode() ?? 0) * 397) ^ (Handle?.GetHashCode(StringComparison.Ordinal) ?? 0); 92 if (!string.Equals(Handle, other.Handle, StringComparison.Ordinal))

BindablePropertyConverter.cs (1)

82 if (strValue.IndexOf(":", StringComparison.Ordinal) != -1)

BindingExpression.cs (2)

235 int lbIndex = part.IndexOf("[", StringComparison.Ordinal); 697 if (name.IndexOf("[", StringComparison.Ordinal) != -1)

BindingExpressionHelper.cs (1)

34 if (stringValue.EndsWith(CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator, StringComparison.Ordinal) && DecimalTypes.Contains(convertTo))

Brush\BrushTypeConverter.cs (12)

DecorableTextElement.cs (1)

40 else if (item.Equals("line-through", StringComparison.OrdinalIgnoreCase))

ExportEffectAttribute.cs (1)

18 if (uniqueName.IndexOf(".", StringComparison.Ordinal) != -1)

FlowDirectionConverter.cs (3)

25 if (strValue.Equals("ltr", StringComparison.OrdinalIgnoreCase)) 27 if (strValue.Equals("rtl", StringComparison.OrdinalIgnoreCase)) 29 if (strValue.Equals("inherit", StringComparison.OrdinalIgnoreCase))

FontAttributes.cs (3)

39 if (strValue.IndexOf(",", StringComparison.Ordinal) != -1) 58 if (part.Equals("normal", StringComparison.OrdinalIgnoreCase)) 60 if (part.Equals("oblique", StringComparison.OrdinalIgnoreCase))

FontSizeConverter.cs (13)

GridLengthTypeConverter.cs (3)

26 if (string.Compare(strValue, "auto", StringComparison.OrdinalIgnoreCase) == 0) 28 if (string.Compare(strValue, "*", StringComparison.OrdinalIgnoreCase) == 0) 30 if (strValue.EndsWith("*", StringComparison.Ordinal) && double.TryParse(strValue.Substring(0, strValue.Length - 1), NumberStyles.Number, CultureInfo.InvariantCulture, out var length))

Internals\ImageParser.cs (2)

265 return !string.IsNullOrEmpty(TypeIdentifier) && TypeIdentifier.StartsWith("GIF", StringComparison.OrdinalIgnoreCase); 477 if (identifier.Equals(NetscapeApplicationExtensionID, StringComparison.OrdinalIgnoreCase))

Items\ItemsLayoutTypeConverter.cs (2)

30 else if (strValue.StartsWith("VerticalGrid", StringComparison.Ordinal)) 35 else if (strValue.StartsWith("HorizontalGrid", StringComparison.Ordinal))

Layout\BoundsTypeConverter.cs (2)

35 if (!hasW && xywh.Length == 4 && string.Compare("AutoSize", xywh[2].Trim(), StringComparison.OrdinalIgnoreCase) == 0) 41 if (!hasH && xywh.Length == 4 && string.Compare("AutoSize", xywh[3].Trim(), StringComparison.OrdinalIgnoreCase) == 0)

Registrar.cs (2)

254 if (specificTypeRenderer.Name.StartsWith("_", StringComparison.Ordinal)) 273 if (specificTypeRenderer.Name.StartsWith("_", StringComparison.Ordinal))

ResourceDictionary.cs (2)

427 if (value.IndexOf(";assembly=", StringComparison.Ordinal) != -1) 445 var resourceUri = uri.OriginalString.StartsWith("/", StringComparison.Ordinal)

ResourcesExtensions.cs (2)

25 else if (res.Key.StartsWith(Style.StyleClassPrefix, StringComparison.Ordinal)) 40 else if (res.Key.StartsWith(Style.StyleClassPrefix, StringComparison.Ordinal))

Routing.cs (2)

79 return source.StartsWith(ImplicitPrefix, StringComparison.Ordinal); 89 return source.StartsWith(DefaultPrefix, StringComparison.Ordinal);

Shell\RequestDefinition.cs (2)

39 if (segments[0].StartsWith("/", StringComparison.Ordinal) || segments[0].StartsWith("\\", StringComparison.Ordinal))

Shell\RouteRequestBuilder.cs (4)

169 if (matchMe.StartsWith("/", StringComparison.Ordinal) || 170 matchMe.StartsWith("\\", StringComparison.Ordinal)) 243 if (segments[0].StartsWith(_uriSeparator, StringComparison.Ordinal) || segments[0].StartsWith("\\", StringComparison.Ordinal))

Shell\ShellNavigationState.cs (1)

70 if (!uri.OriginalString.StartsWith("//", StringComparison.Ordinal))

Shell\ShellRouteParameters.cs (3)

47 if (!q.Key.StartsWith(prefix, StringComparison.Ordinal)) 50 if (key.IndexOf(".", StringComparison.Ordinal) != -1) 103 if (query.StartsWith("?", StringComparison.Ordinal))

Shell\ShellUriHandler.cs (9)

StyleSheets\Selector.cs (2)

201 string.Equals(styleable.NameAndBases[0], ElementName, StringComparison.OrdinalIgnoreCase); 215 if (string.Equals(styleable.NameAndBases[i], ElementName, StringComparison.OrdinalIgnoreCase))

StyleSheets\Style.cs (1)

73 if (string.Equals(decl.Value, "initial", StringComparison.OrdinalIgnoreCase))

TextAlignment.cs (11)

VisualElement\VisualElement.cs (17)

Visuals\VisualTypeConverter.cs (1)

125 if (name.EndsWith("Visual", StringComparison.OrdinalIgnoreCase))

VisualStateManager.cs (1)

420 if (string.Equals(state.Name, name, StringComparison.Ordinal))

WebView\WebView.cs (1)

298 if (js.IndexOf("'", StringComparison.Ordinal) == -1)

Xaml\TypeConversionExtensions.cs (1)

205 if (toType == typeof(String) && str.StartsWith("{}", StringComparison.Ordinal))

BindablePropertyReferenceExtensions.cs (2)

14 if (!bpRef.Name.EndsWith("Property", StringComparison.InvariantCulture)) 36 var bpName = bpRef.Name.EndsWith("Property", StringComparison.Ordinal) ? bpRef.Name.Substring(0, bpRef.Name.Length - 8) : bpRef.Name;

CompiledConverters\BoundsTypeConverter.cs (2)

33 if (!hasW && xywh.Length == 4 && string.Compare("AutoSize", xywh[2].Trim(), StringComparison.OrdinalIgnoreCase) == 0) 39 if (!hasH && xywh.Length == 4 && string.Compare("AutoSize", xywh[3].Trim(), StringComparison.OrdinalIgnoreCase) == 0)

CompiledConverters\BrushTypeConverter.cs (1)

19 if (value.StartsWith("#", StringComparison.Ordinal))

CompiledConverters\ColorTypeConverter.cs (1)

23 if (value.StartsWith("#", StringComparison.Ordinal))

CompiledConverters\FlexBasisTypeConverter.cs (1)

27 if (value.EndsWith("%", StringComparison.OrdinalIgnoreCase)

CompiledConverters\GridLengthTypeConverter.cs (3)

22 if (value.Equals("auto", StringComparison.OrdinalIgnoreCase)) 27 if (value.Equals("*", StringComparison.OrdinalIgnoreCase)) 32 if (value.EndsWith("*", StringComparison.OrdinalIgnoreCase) && double.TryParse(value.Substring(0, value.Length - 1), NumberStyles.Number, CultureInfo.InvariantCulture, out var length))

CompiledConverters\StrokeShapeTypeConverter.cs (7)

24 if (value.StartsWith(ShapeConverter.Ellipse, StringComparison.Ordinal)) 31 if (value.StartsWith(ShapeConverter.Line, StringComparison.Ordinal)) 80 if (value.StartsWith(ShapeConverter.Path, StringComparison.Ordinal)) 102 if (value.StartsWith(ShapeConverter.Polygon, StringComparison.Ordinal)) 130 if (value.StartsWith(ShapeConverter.Polyline, StringComparison.Ordinal)) 158 if (value.StartsWith(ShapeConverter.Rectangle, StringComparison.Ordinal)) 164 if (value.StartsWith(ShapeConverter.RoundRectangle, StringComparison.Ordinal))

ExpandMarkupsVisitor.cs (2)

86 if (expression.StartsWith("{}", StringComparison.Ordinal)) 142 if (remaining.StartsWith("}", StringComparison.Ordinal))

ModuleDefinitionExtensions.cs (5)

110 string.Equals(pd.Name, propertyName, caseSensitive ? StringComparison.InvariantCulture : StringComparison.InvariantCultureIgnoreCase) 242 string.Equals(fd.Name, fieldName, caseSensitive ? StringComparison.InvariantCulture : StringComparison.InvariantCultureIgnoreCase) 303 visibleTo.StartsWith(to.Assembly.Name.Name, StringComparison.InvariantCulture));

NodeILExtensions.cs (1)

277 else if (targetTypeRef.FullName == "System.String" && str.StartsWith("{}", StringComparison.Ordinal))

SetPropertiesVisitor.cs (1)

577 var prefix = dataType.Contains(":") ? dataType.Substring(0, dataType.IndexOf(":", StringComparison.Ordinal)) : "";

SetResourcesVisitor.cs (1)

44 if ((propertyName.LocalName == "Resources" || propertyName.LocalName.EndsWith(".Resources", StringComparison.Ordinal)))

TypeReferenceExtensions.cs (13)

XamlTask.cs (1)

73 if (!resource.Name.EndsWith(".xaml", StringComparison.InvariantCulture))

BoundsDesignTypeConverter.cs (2)

23 if (!hasW && xywh.Length == 4 && string.Compare("AutoSize", xywh[2].Trim(), StringComparison.OrdinalIgnoreCase) == 0) 28 if (!hasH && xywh.Length == 4 && string.Compare("AutoSize", xywh[3].Trim(), StringComparison.OrdinalIgnoreCase) == 0)

CornerRadiusDesignTypeConverter.cs (1)

16 if (strValue.IndexOf(",", StringComparison.Ordinal) != -1)

FlexEnumDesignTypeConverters.cs (2)

107 if (KnownValues.Any(v => value?.ToString()?.Equals(v, StringComparison.Ordinal) ?? false)) 115 if (strValue.EndsWith("%", StringComparison.OrdinalIgnoreCase) && float.TryParse(strValue.Substring(0, strValue.Length - 1), NumberStyles.Number, CultureInfo.InvariantCulture, out float relflex))

FontSizeDesignTypeConverter.cs (1)

17 if (KnownValues.Any(v => value?.ToString()?.Equals(v, StringComparison.Ordinal) ?? false))

GridLengthDesignTypeConverter.cs (3)

25 if (string.Compare(value, "auto", StringComparison.OrdinalIgnoreCase) == 0) 27 if (string.Compare(value, "*", StringComparison.OrdinalIgnoreCase) == 0) 29 if (value.EndsWith("*", StringComparison.Ordinal) && double.TryParse(value.Substring(0, value.Length - 1), NumberStyles.Number, CultureInfo.InvariantCulture, out var len))

KnownValuesDesignTypeConverter.cs (1)

32 return KnownValues.Any(v => value?.ToString()?.Equals(v, StringComparison.Ordinal) ?? false);

ThicknessTypeDesignConverter.cs (1)

16 if (strValue.IndexOf(",", StringComparison.Ordinal) != -1)

Pin.cs (4)

113 int hashCode = Label?.GetHashCode(StringComparison.Ordinal) ?? 0; 116 hashCode = (hashCode * 397) ^ (Address?.GetHashCode(StringComparison.Ordinal) ?? 0); 172 return string.Equals(Label, other.Label, StringComparison.Ordinal) && 174 string.Equals(Address, other.Address, StringComparison.Ordinal);

CodeBehindGenerator.cs (7)

454 return !parts[indexOfCompile + 1].Trim('"', '\'').Equals("false", StringComparison.OrdinalIgnoreCase); 531 !namespaceuri.StartsWith("clr-namespace", StringComparison.InvariantCulture) && 532 !namespaceuri.StartsWith("using:", StringComparison.InvariantCulture)) 658 if (targetFramework.IndexOf("-android", StringComparison.OrdinalIgnoreCase) != -1) 663 if (targetFramework.IndexOf("-ios", StringComparison.OrdinalIgnoreCase) != -1) 668 if (targetFramework.IndexOf("-macos", StringComparison.OrdinalIgnoreCase) != -1) 673 if (targetFramework.IndexOf("-maccatalyst", StringComparison.OrdinalIgnoreCase) != -1)

src\Controls\src\Xaml\TypeArgumentsParser.cs (2)

60 var openBracket = type.IndexOf("(", StringComparison.Ordinal); 62 type.Substring(openBracket + 1, type.LastIndexOf(")", StringComparison.Ordinal) - openBracket - 1), resolver, lineinfo);

src\Controls\src\Xaml\XmlnsHelper.cs (6)

26 if (xmlns.StartsWith("using:", StringComparison.Ordinal)) 40 if (decl.StartsWith("clr-namespace:", StringComparison.Ordinal)) 45 if (decl.StartsWith("assembly=", StringComparison.Ordinal)) 50 if (decl.StartsWith("targetPlatform=", StringComparison.Ordinal)) 55 var nsind = decl.LastIndexOf(".", StringComparison.Ordinal); 72 if (decl.StartsWith("using:", StringComparison.Ordinal))

src\Controls\src\Xaml\XmlTypeXamlExtensions.cs (3)

65 if (expandToExtension && elementName != "DataTemplate" && !elementName.EndsWith("Extension", StringComparison.Ordinal)) 72 var lastIndex = name.LastIndexOf(":", StringComparison.Ordinal); 89 (assemblyName == "mscorlib" || assemblyName.StartsWith("mscorlib,", StringComparison.Ordinal)))

ApplyPropertiesVisitor.cs (1)

302 var dotIdx = localname.IndexOf(".", StringComparison.Ordinal);

ExpandMarkupsVisitor.cs (2)

80 if (expression.StartsWith("{}", StringComparison.Ordinal)) 140 if (remaining.StartsWith("}", StringComparison.Ordinal))

FillResourceDictionariesVisitor.cs (1)

49 propertyName.LocalName.EndsWith(".Resources", StringComparison.Ordinal)) && value is ResourceDictionary)

MarkupExpressionParser.cs (1)

55 if (expression.StartsWith("{}", StringComparison.Ordinal))

MarkupExtensions\StaticExtension.cs (1)

23 if (string.IsNullOrEmpty(Member) || Member.IndexOf(".", StringComparison.Ordinal) == -1)

SimplifyOnPlatformVisitor.cs (4)

16 if (targetFramework.IndexOf("-android", StringComparison.OrdinalIgnoreCase) != -1) 18 if (targetFramework.IndexOf("-ios", StringComparison.OrdinalIgnoreCase) != -1) 20 if (targetFramework.IndexOf("-macos", StringComparison.OrdinalIgnoreCase) != -1) 22 if (targetFramework.IndexOf("-maccatalyst", StringComparison.OrdinalIgnoreCase) != -1)

TypeArgumentsParser.cs (2)

60 var openBracket = type.IndexOf("(", StringComparison.Ordinal); 62 type.Substring(openBracket + 1, type.LastIndexOf(")", StringComparison.Ordinal) - openBracket - 1), resolver, lineinfo);

XamlLoader.cs (6)

293 if (!resource.EndsWith(".xaml", StringComparison.OrdinalIgnoreCase)) 304 if (resource.EndsWith(".xaml", StringComparison.OrdinalIgnoreCase)) 324 string.Compare(info.FileName, filename, StringComparison.OrdinalIgnoreCase) == 0) 332 if (resource.EndsWith("." + filename, StringComparison.OrdinalIgnoreCase) || 333 string.Compare(resource, filename, StringComparison.OrdinalIgnoreCase) == 0) 432 if (!MemoryExtensions.Equals(slice, fullName.AsSpan(), StringComparison.Ordinal))

XamlNode.cs (2)

80 int hashCode = NamespaceUri.GetHashCode(StringComparison.Ordinal); 81 hashCode = (hashCode * 397) ^ Name.GetHashCode(StringComparison.Ordinal);

XamlParser.cs (6)

71 if (reader.Name.IndexOf(".", StringComparison.Ordinal) != -1) 74 if (reader.Name.StartsWith(elementName + ".", StringComparison.Ordinal)) 221 if (reader.LocalName.IndexOf(".", StringComparison.Ordinal) != -1 && namespaceUri == "") 320 if (valueString != null && valueString.Trim().StartsWith("{}", StringComparison.Ordinal)) 325 if (valueString != null && valueString.Trim().StartsWith("{", StringComparison.Ordinal)) 450 ca.AssemblyName.StartsWith(to.GetName().Name, StringComparison.InvariantCulture));

XmlName.cs (2)

53 hashCode = NamespaceURI.GetHashCode(StringComparison.Ordinal); 55 hashCode = (hashCode * 397) ^ LocalName.GetHashCode(StringComparison.Ordinal);

XmlnsHelper.cs (6)

26 if (xmlns.StartsWith("using:", StringComparison.Ordinal)) 40 if (decl.StartsWith("clr-namespace:", StringComparison.Ordinal)) 45 if (decl.StartsWith("assembly=", StringComparison.Ordinal)) 50 if (decl.StartsWith("targetPlatform=", StringComparison.Ordinal)) 55 var nsind = decl.LastIndexOf(".", StringComparison.Ordinal); 72 if (decl.StartsWith("using:", StringComparison.Ordinal))

XmlTypeXamlExtensions.cs (3)

65 if (expandToExtension && elementName != "DataTemplate" && !elementName.EndsWith("Extension", StringComparison.Ordinal)) 72 var lastIndex = name.LastIndexOf(":", StringComparison.Ordinal); 89 (assemblyName == "mscorlib" || assemblyName.StartsWith("mscorlib,", StringComparison.Ordinal)))

Types\DeviceIdiom.shared.cs (2)

70 string.Equals(deviceIdiom, other, StringComparison.Ordinal); 83 StringComparison.Ordinal

Types\DevicePlatform.shared.cs (2)

93 string.Equals(devicePlatform, other, StringComparison.Ordinal); 106 StringComparison.Ordinal

Types\Shared\WebUtils.shared.cs (2)

92 if (!callbackUrl.Scheme.Equals(expectedUrl.Scheme, StringComparison.OrdinalIgnoreCase)) 97 if (!callbackUrl.Host.Equals(expectedUrl.Host, StringComparison.OrdinalIgnoreCase))

Color.cs (6)

610 if (value.StartsWith("rgba".AsSpan(), StringComparison.OrdinalIgnoreCase)) 633 if (value.StartsWith("rgb".AsSpan(), StringComparison.OrdinalIgnoreCase)) 654 if (value.StartsWith("hsla".AsSpan(), StringComparison.OrdinalIgnoreCase)) 677 if (value.StartsWith("hsl".AsSpan(), StringComparison.OrdinalIgnoreCase)) 698 if (value.StartsWith("hsva".AsSpan(), StringComparison.OrdinalIgnoreCase)) 721 if (value.StartsWith("hsv".AsSpan(), StringComparison.OrdinalIgnoreCase))

Font.cs (1)

51 ((Name is null && other.Name is null) || Name.Equals(other.Name, StringComparison.OrdinalIgnoreCase));

FontSource.cs (2)

20 => Name.Equals(other.Name, StringComparison.Ordinal) 26 StringComparison.Ordinal

InvariantExtensions.cs (1)

20 return target.Equals(value, StringComparison.OrdinalIgnoreCase);

PathBuilder.cs (5)

35 if ("1".Equals(vValueAsString, StringComparison.Ordinal)) 117 pathAsString = pathAsString.Replace("Infinity", "0", StringComparison.Ordinal); 125 pathAsString = pathAsString.Replace("-", " -", StringComparison.Ordinal); 126 pathAsString = pathAsString.Replace(" E -", "E-", StringComparison.Ordinal); 127 pathAsString = pathAsString.Replace(" e -", "e-", StringComparison.Ordinal);

PdfExportContext.cs (1)

22 if ("en-US".Equals(Thread.CurrentThread.CurrentCulture.Name, StringComparison.Ordinal))

Text\TextColors.cs (2)

159 if (!color.StartsWith("#", StringComparison.Ordinal)) 202 if (!color.StartsWith("#", StringComparison.Ordinal))

Text\XmlAttributedTextReader.cs (5)

74 if (XmlNames.Content.Equals(elementName, StringComparison.Ordinal)) 79 else if (XmlNames.Run.Equals(elementName, StringComparison.Ordinal)) 88 if (XmlNames.Content.Equals(elementName, StringComparison.Ordinal)) 124 if (!(XmlNames.Start.Equals(attributeName, StringComparison.Ordinal) || XmlNames.Length.Equals(attributeName, StringComparison.Ordinal)))

Text\XmlAttributedTextWriter.cs (2)

26 bool encode = attributedText.Text.IndexOf("]]", StringComparison.Ordinal) != -1; 86 if (!string.Equals(value, defaultValue, StringComparison.Ordinal))

Renderer\HtmlInlineRenderer.cs (4)

15 if (tag.StartsWith("<span ", StringComparison.Ordinal) 16 && !tag.EndsWith("/>", StringComparison.Ordinal)) 18 var styleIndex = tag.IndexOf("style", StringComparison.Ordinal); 36 else if (tag.Equals("</span>", StringComparison.Ordinal))

GetMauiAssetPath.cs (1)

86 if (path.StartsWith(projectDirectory, StringComparison.OrdinalIgnoreCase))

ResizeImageInfo.cs (1)

57 => extension?.Equals(".svg", StringComparison.OrdinalIgnoreCase) ?? false;

ColumnInference\PurposeInference.cs (1)

138if (spanStr.EndsWith(ext, StringComparison.OrdinalIgnoreCase))

Utils\SweepableParamAttributes.cs (2)

99var index1 = name.LastIndexOf(".", StringComparison.Ordinal); 100var index2 = name.Substring(0, index1).LastIndexOf(".", StringComparison.Ordinal) + 1;

Template\EstimatorType.cs (1)

168if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture))

Template\SearchSpace.cs (1)

185if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture))

Template\SweepableEstimator.cs (1)

187if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture))

Template\SweepableEstimator_T_.cs (1)

192if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture))

Template\SweepableEstimatorFactory.cs (1)

163if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture))

Templates\Azure\Console\AzureModelBuilder.cs (1)

262if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture))

Templates\Azure\Model\AzureImageModelOutputClass.cs (1)

203if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture))

Templates\Azure\Model\AzureObjectDetectionModelOutputClass.cs (1)

203if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture))

Templates\Console\ConsumeModel.cs (1)

214if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture))

Templates\Console\ModelBuilder.cs (1)

579if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture))

Templates\Console\ModelInputClass.cs (1)

177if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture))

Templates\Console\ModelOutputClass.cs (1)

220if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture))

Templates\Console\ModelProject.cs (1)

209if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture))

Templates\Console\PredictProgram.cs (1)

236if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture))

Templates\Console\PredictProject.cs (1)

214if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture))

ComponentModel\AssemblyLoadingUtils.cs (1)

181if (name.StartsWith(s, StringComparison.OrdinalIgnoreCase))

ComponentModel\ComponentCatalog.cs (2)

900return aliases.Any(a => string.Equals(name, a, StringComparison.OrdinalIgnoreCase)); 1113if (assembly.FullName.StartsWith("Microsoft.ML.", StringComparison.Ordinal)

EntryPoints\ModuleArgs.cs (2)

379var index1 = name.LastIndexOf(".", StringComparison.Ordinal); 380var index2 = name.Substring(0, index1).LastIndexOf(".", StringComparison.Ordinal) + 1;

Utilities\Utils.cs (2)

25return str.StartsWith(startsWith, StringComparison.InvariantCultureIgnoreCase); 30return str.StartsWith(startsWith, StringComparison.InvariantCulture);

PerformanceTests.cs (1)

57if (string.Equals(cpumathSeed, "random", StringComparison.OrdinalIgnoreCase))

UnitTests.cs (1)

36public static bool IsNetCore => Environment.Version.Major >= 5 || RuntimeInformation.FrameworkDescription.StartsWith(".NET Core", StringComparison.OrdinalIgnoreCase);

Commands\DataCommand.cs (4)

356string.Equals(ext, ".txt", StringComparison.OrdinalIgnoreCase) || 357string.Equals(ext, ".tlc", StringComparison.OrdinalIgnoreCase); 358var isBinary = string.Equals(ext, ".idv", StringComparison.OrdinalIgnoreCase); 359var isTranspose = string.Equals(ext, ".tdv", StringComparison.OrdinalIgnoreCase);

Commands\EvaluateCommand.cs (1)

74if (input.Equals(LoadName, StringComparison.OrdinalIgnoreCase) || (CanBeWeighted && input == "Weighted" + LoadName))

Commands\SaveDataCommand.cs (2)

65var isBinary = string.Equals(ext, ".idv", StringComparison.OrdinalIgnoreCase); 66var isTranspose = string.Equals(ext, ".tdv", StringComparison.OrdinalIgnoreCase);

EntryPoints\EntryPointNode.cs (4)

1227return asSelf.ParameterName.Equals(ParameterName, StringComparison.Ordinal); 1254asSelf.ParameterName.Equals(ParameterName, StringComparison.Ordinal) && 1255asSelf.Key.Equals(Key, StringComparison.Ordinal); 1282asSelf.ParameterName.Equals(ParameterName, StringComparison.Ordinal) &&

EntryPoints\InputBuilder.cs (1)

96return aliases.Any(a => string.Equals(name, a, StringComparison.OrdinalIgnoreCase));

TrainCatalog.cs (1)

122while (!type!.FullName!.StartsWith("Microsoft.ML.Data.TransformerChain`1[", StringComparison.Ordinal))

Transforms\ValueMapping.cs (1)

622if (extension.Equals(".idv", StringComparison.OrdinalIgnoreCase))

Transforms\ValueToKeyMappingTransformer.cs (2)

413bool isBinary = string.Equals(ext, ".idv", StringComparison.OrdinalIgnoreCase); 414bool isTranspose = string.Equals(ext, ".tdv", StringComparison.OrdinalIgnoreCase);

Transforms\ValueToKeyMappingTransformerImpl.cs (2)

125Comparison<int> comp = (i, j) => _pool.GetNormStrById(i).Value.Span.CompareTo(_pool.GetNormStrById(j).Value.Span, StringComparison.Ordinal); 133Contracts.Assert(i == 0 || sortedPool.GetNormStrById(i - 1).Value.Span.CompareTo(sortedPool.GetNormStrById(i).Value.Span, StringComparison.Ordinal) < 0);

NameAnalyzer.cs (1)

141=> !string.IsNullOrEmpty(name) && name.StartsWith("_", StringComparison.OrdinalIgnoreCase) && Utils.NameIsGood(name, 1, false);

NameFixProvider.cs (2)

65if (docName.Length - 3 == originalName.Length && docName.EndsWith(".cs", StringComparison.OrdinalIgnoreCase) 66&& context.Document.Name.StartsWith(originalName, StringComparison.OrdinalIgnoreCase))

PartitionedPathUtils.cs (1)

53if (uri.Scheme.Equals("file", StringComparison.OrdinalIgnoreCase))

ResultProcessor.cs (3)

438string.Equals(x.Name, "CV", StringComparison.OrdinalIgnoreCase) || 439string.Equals(x.Name, "TrainTest", StringComparison.OrdinalIgnoreCase) || 440string.Equals(x.Name, "Test", StringComparison.OrdinalIgnoreCase));

Dynamic\DataOperations\FilterRowsByCustomPredicate.cs (1)

49data, input => input.Name.StartsWith("r", StringComparison.OrdinalIgnoreCase));

Dynamic\DataOperations\FilterRowsByStatefulCustomPredicate.cs (1)

53return (filter && input.Name.StartsWith("r", StringComparison.OrdinalIgnoreCase));

ConfigRunner.cs (2)

104if (Exe == null || Exe.EndsWith("maml", StringComparison.OrdinalIgnoreCase) || 105Exe.EndsWith("maml.exe", StringComparison.OrdinalIgnoreCase))

CachingTests.cs (1)

69StringComparison.InvariantCultureIgnoreCase);

ImagesTests.cs (4)

1284if (extension.Equals(".jpeg", StringComparison.OrdinalIgnoreCase) || 1285extension.Equals(".jpg", StringComparison.OrdinalIgnoreCase) || 1286extension.Equals(".png", StringComparison.OrdinalIgnoreCase) || 1287extension.Equals(".webp", StringComparison.OrdinalIgnoreCase))

Model\BPETokenizer.cs (7)

854if (EndOfWordSuffix is not null && span.EndsWith(EndOfWordSuffix.AsSpan(), StringComparison.Ordinal)) 859if (ContinuingSubwordPrefix is not null && span.StartsWith(ContinuingSubwordPrefix.AsSpan(), StringComparison.Ordinal)) 945if (continuingSubwordPrefix && sSpan.StartsWith(ContinuingSubwordPrefix.AsSpan(), StringComparison.Ordinal)) 951if (endOfWordSuffix && sSpan.EndsWith(EndOfWordSuffix!.AsSpan(), StringComparison.Ordinal)) 1030if (EndOfWordSuffix is not null && span.EndsWith(EndOfWordSuffix.AsSpan(), StringComparison.Ordinal)) 1035if (ContinuingSubwordPrefix is not null && span.StartsWith(ContinuingSubwordPrefix.AsSpan(), StringComparison.Ordinal)) 1155if (line.StartsWith("#version", StringComparison.Ordinal) || line.Length == 0)

Model\TiktokenTokenizer.cs (8)

Model\WordPieceTokenizer.cs (1)

753if (token.StartsWith(ContinuingSubwordPrefix, StringComparison.Ordinal))

Utils\ValueStringBuilder.cs (1)

166int subIndex = buffer.IndexOf(oldValue.AsSpan(), StringComparison.Ordinal);

BpeTests.cs (5)

887!"BPE".Equals(typeElement.GetString(), StringComparison.OrdinalIgnoreCase) || 964"Sequence".Equals(typeElement.GetString(), StringComparison.OrdinalIgnoreCase) && 975if ("Split".Equals(preTokenizerType, StringComparison.OrdinalIgnoreCase)) 987else if ("ByteLevel".Equals(preTokenizerType, StringComparison.OrdinalIgnoreCase)) 1012if (content is not null && !content.StartsWith("<｜place▁holder", StringComparison.OrdinalIgnoreCase))

DoubleArrayTrieTest.cs (1)

84Assert.StartsWith(Helpers.GetString(utf8Bytes.AsSpan(0, doubleArrayResultPairs[i].Length)), key, StringComparison.Ordinal);

Text\StopWordsRemovingTransformer.cs (2)

791bool isBinary = string.Equals(ext, ".idv", StringComparison.OrdinalIgnoreCase); 792bool isTranspose = string.Equals(ext, ".tdv", StringComparison.OrdinalIgnoreCase);

CacheControlHeaderValue.cs (12)

ContentDispositionHeaderValue.cs (5)

240return _dispositionType.Equals(other._dispositionType, StringComparison.OrdinalIgnoreCase) && 444if (parameter.EndsWith("*", StringComparison.Ordinal)) 529return value.Length > 1 && value.StartsWith("\"", StringComparison.Ordinal) 530&& value.EndsWith("\"", StringComparison.Ordinal); 589|| !parts[2].Equals("b", StringComparison.OrdinalIgnoreCase))

ContentRangeHeaderValue.cs (1)

152StringSegment.Equals(Unit, other.Unit, StringComparison.OrdinalIgnoreCase));

CookieHeaderValue.cs (2)

203return StringSegment.Equals(_name, other._name, StringComparison.OrdinalIgnoreCase) 204&& StringSegment.Equals(_value, other._value, StringComparison.OrdinalIgnoreCase);

EntityTagHeaderValue.cs (4)

55if (!isWeak && StringSegment.Equals(tag, "*", StringComparison.Ordinal)) 109return obj is EntityTagHeaderValue other && _isWeak == other._isWeak && StringSegment.Equals(_tag, other._tag, StringComparison.Ordinal); 137return !IsWeak && !other.IsWeak && StringSegment.Equals(Tag, other.Tag, StringComparison.Ordinal); 141return StringSegment.Equals(Tag, other.Tag, StringComparison.Ordinal);

HeaderUtilities.cs (2)

253&& string.Compare(headerValues[i], current, targetValue, 0, tokenLength, StringComparison.OrdinalIgnoreCase) == 0 309&& string.Compare(segment, current, targetDirectives, 0, tokenLength, StringComparison.OrdinalIgnoreCase) == 0)

MediaTypeHeaderValue.cs (18)

MediaTypeHeaderValueComparer.cs (3)

55if (!mediaType1.Type.Equals(mediaType2.Type, StringComparison.OrdinalIgnoreCase)) 82else if (!mediaType1.SubType.Equals(mediaType2.SubType, StringComparison.OrdinalIgnoreCase)) 101else if (!mediaType1.Suffix.Equals(mediaType2.Suffix, StringComparison.OrdinalIgnoreCase))

NameValueHeaderValue.cs (4)

147if (!_name.Equals(other._name, StringComparison.OrdinalIgnoreCase)) 164return (_value.Equals(other._value, StringComparison.Ordinal)); 168return (_value.Equals(other._value, StringComparison.OrdinalIgnoreCase)); 446if (value.Name.Equals(name, StringComparison.OrdinalIgnoreCase))

RangeHeaderValue.cs (1)

112return StringSegment.Equals(_unit, other._unit, StringComparison.OrdinalIgnoreCase) &&

SetCookieHeaderValue.cs (14)

StringWithQualityHeaderValue.cs (1)

89if (!StringSegment.Equals(_value, other._value, StringComparison.OrdinalIgnoreCase))

StringWithQualityHeaderValueComparer.cs (3)

58if (!StringSegment.Equals(stringWithQuality1.Value, stringWithQuality2.Value, StringComparison.OrdinalIgnoreCase)) 60if (StringSegment.Equals(stringWithQuality1.Value, Any, StringComparison.Ordinal)) 64else if (StringSegment.Equals(stringWithQuality2.Value, Any, StringComparison.Ordinal))

Microsoft\VisualBasic\CompilerServices\Symbols.vb (1)

173Return method.IsSpecialName AndAlso method.Name.StartsWith("op_", StringComparison.Ordinal)

Microsoft\VisualBasic\DateAndTime.vb (3)

83Return String.Equals(langName, "zh", StringComparison.OrdinalIgnoreCase) OrElse _ 84String.Equals(langName, "ko", StringComparison.OrdinalIgnoreCase) OrElse _ 85String.Equals(langName, "ja", StringComparison.OrdinalIgnoreCase)

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

Microsoft\VisualBasic\FileIO\TextFieldParser.vb (3)

634If TrimmedLine.StartsWith(Token, StringComparison.Ordinal) Then 639If line.StartsWith(Token, StringComparison.Ordinal) Then 1238If String.Equals(Token.Trim(), """", StringComparison.Ordinal) Then

Microsoft\VisualBasic\FileSystem.vb (1)

1351If System.String.Equals(sPath, oFile.GetAbsolutePath(), StringComparison.OrdinalIgnoreCase) Then

Microsoft\VisualBasic\Interaction.vb (1)

516If String.Equals(Environment.MachineName, ServerName, StringComparison.OrdinalIgnoreCase) Then

Microsoft\VisualBasic\Strings.vb (16)

CommonControls\NewTypeDestinationSelectionViewModel.cs (1)

132if (!Path.GetExtension(trimmedFileName).Equals(_fileExtension, StringComparison.OrdinalIgnoreCase))

DesignerAttribute\VisualStudioDesignerAttributeService.cs (1)

221if (string.Equals(currentStringValue, data.Category, StringComparison.OrdinalIgnoreCase))

Diagnostics\VisualStudioDiagnosticAnalyzerProvider.cs (1)

125return string.Equals(content_ContentTypeName, contentTypeName, StringComparison.InvariantCultureIgnoreCase);

DocumentationComments\VisualStudioDocumentationProvider.cs (1)

64string.Equals(_filePath, other._filePath, StringComparison.OrdinalIgnoreCase);

EditorConfigSettings\SettingsEditorPane.SearchFilter.cs (1)

131=> (columnValue is not null) && (columnValue.IndexOf(searchToken.ParsedTokenText, StringComparison.OrdinalIgnoreCase) >= 0);

GenerateType\GenerateTypeDialogViewModel.cs (9)

Implementation\AbstractEditorFactory.cs (1)

193return "Form".Equals(pszPhysicalView, StringComparison.OrdinalIgnoreCase);

InheritanceMargin\MarginGlyph\InheritanceMarginGlyphViewModel.cs (1)

58var startOfThePlaceholder = ServicesVSResources._0_is_inherited.IndexOf("{0}", StringComparison.Ordinal);

Interactive\VsResetInteractive.cs (2)

169if (targetFrameworkMoniker.StartsWith(".NETCoreApp", StringComparison.OrdinalIgnoreCase) || 170targetFrameworkMoniker.StartsWith(".NETStandard", StringComparison.OrdinalIgnoreCase))

Library\ObjectBrowser\AbstractDescriptionBuilder.cs (1)

251var index = memberOfText.IndexOf(specifier, StringComparison.Ordinal);

Library\ObjectBrowser\AbstractListItemFactory.cs (4)

424else if (namespaceListItem.SearchText.IndexOf(searchString, StringComparison.OrdinalIgnoreCase) >= 0) 709if (listItem.DisplayText.IndexOf(searchString, StringComparison.OrdinalIgnoreCase) >= 0) 761else if (typeListItem.SearchText.IndexOf(searchString, StringComparison.OrdinalIgnoreCase) >= 0) 796else if (memberListItem.SearchText.IndexOf(searchString, StringComparison.OrdinalIgnoreCase) >= 0)

Library\ObjectBrowser\ObjectList.cs (4)

622if (string.Equals(matchName, name, StringComparison.Ordinal)) 630if (string.Equals(matchName, name, StringComparison.Ordinal)) 637if (matchName.IndexOf(name, StringComparison.OrdinalIgnoreCase) >= 0) 850if (string.Equals(data.bstrFile, metadataReference.FilePath, StringComparison.OrdinalIgnoreCase))

PickMembers\PickMembersDialogViewModel.cs (1)

55: [.. _allMembers.Where(m => m.SymbolAutomationText.IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0)];

Progression\GraphNavigatorExtension.cs (1)

78StringComparison.OrdinalIgnoreCase));

Progression\GraphQueries\ContainsChildrenGraphQuery.cs (2)

70if (path.EndsWith(".cs", StringComparison.OrdinalIgnoreCase) || path.EndsWith(".vb", StringComparison.OrdinalIgnoreCase))

ProjectSystem\FileChangeWatcher.cs (1)

396if (WatchedDirectory.FilePathCoveredByWatchedDirectories(_watchedDirectories, filePath, StringComparison.OrdinalIgnoreCase))

ProjectSystem\Legacy\AbstractLegacyProject.cs (1)

386if (!name.StartsWith("<", StringComparison.OrdinalIgnoreCase))

ProjectSystem\MetadataReferences\VisualStudioMetadataReferenceManager.cs (1)

133=> _runtimeDirectories.Any(static (d, fullPath) => fullPath.StartsWith(d, StringComparison.OrdinalIgnoreCase), fullPath);

ProjectSystem\RuleSets\RuleSetEventHandler.cs (4)

92if (Path.GetExtension(oldFileFullPath).Equals(".ruleset", StringComparison.OrdinalIgnoreCase)) 171Path.GetExtension(fileFullPath).Equals(".ruleset", StringComparison.OrdinalIgnoreCase)) 191Path.GetExtension(fileFullPath).Equals(".ruleset", StringComparison.OrdinalIgnoreCase)) 251if (codeAnalysisRuleSetFullPath.Equals(oldRuleSetFilePath, StringComparison.OrdinalIgnoreCase))

Snippets\SnippetExpansionClient.cs (1)

316if (codeNode.Value.IndexOf(string.Format("{0}end{0}", delimiter), StringComparison.OrdinalIgnoreCase) != -1)

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

64string.Equals(this.FullPath, other.FullPath, StringComparison.OrdinalIgnoreCase);

SyncNamespaces\SyncNamespacesCommandHandler.cs (3)

78.Any(project => project.Language.Equals(LanguageNames.CSharp, StringComparison.OrdinalIgnoreCase)); 107.Where(project => project.Language.Equals(LanguageNames.CSharp, StringComparison.OrdinalIgnoreCase)) 120.Where(project => project.FilePath?.Equals(projectFilePath, StringComparison.OrdinalIgnoreCase) == true)

TaskList\ProjectExternalErrorReporter.cs (2)

334if (prefix.Equals("CS", StringComparison.OrdinalIgnoreCase) || prefix.Equals("BC", StringComparison.OrdinalIgnoreCase))

UnusedReferences\Dialog\UnusedReferencesTableProvider.DataSource.cs (1)

36var project = solution.Projects.First(project => projectFilePath.Equals(project.FilePath, StringComparison.OrdinalIgnoreCase));

Venus\ContainedDocument.cs (5)

625if (leftText.IndexOf(initialReplacement, StringComparison.Ordinal) < 0 && rightText.IndexOf(initialReplacement, StringComparison.Ordinal) < 0) 635if (leftText.IndexOf(replacement, StringComparison.Ordinal) < 0 && rightText.IndexOf(replacement, StringComparison.Ordinal) < 0) 1080return string.Equals(razorTag, tag, StringComparison.OrdinalIgnoreCase) && (!checkAt || snapshot[start - 1] == RazorExplicit);

Venus\ContainedLanguageCodeSupport.cs (1)

241if (!newMemberText.EndsWith(Environment.NewLine, StringComparison.Ordinal))

CodeModel\CSharpCodeModelService.cs (1)

1365if (line.StartsWith("///", StringComparison.Ordinal))

CodeModel\CSharpCodeModelService.NodeNameGenerator.cs (2)

142if (name.EndsWith("Keyword", StringComparison.Ordinal)) 146else if (name.EndsWith("Token", StringComparison.Ordinal))

CodeModel\FileCodeFunctionTests.cs (2)

497var position = text.ToString().IndexOf("DynamicMethod", StringComparison.Ordinal); 510var position = text.ToString().IndexOf("protected virtual string MethodB", StringComparison.Ordinal) - 1;

Implementation\XamlProjectService.cs (1)

230if (oldMoniker.Equals(newMoniker, StringComparison.OrdinalIgnoreCase))

InsertOrAppendAttribute.cs (3)

58if (trimmedArg.StartsWith(name, StringComparison.OrdinalIgnoreCase)) 94if (string.Equals(att.Name, AttributeName, StringComparison.OrdinalIgnoreCase)) 111if (string.Equals(att.Name, AttributeName, StringComparison.OrdinalIgnoreCase))

AssemblyNameExtension.cs (8)

BuildEnvironmentHelper.cs (5)

360directory.EndsWith(@"\amd64", StringComparison.OrdinalIgnoreCase) || 361directory.EndsWith(@"\arm64", StringComparison.OrdinalIgnoreCase) 423processFileName.Equals(s, StringComparison.OrdinalIgnoreCase)); 594if (string.Equals(currentToolsDirectory.Name, "amd64", StringComparison.OrdinalIgnoreCase) || 595string.Equals(currentToolsDirectory.Name, "arm64", StringComparison.OrdinalIgnoreCase))

CollectionHelpers.cs (1)

41internal static bool ContainsValueAndIsEqual(this Dictionary<string, string> dictionary, string key, string value, StringComparison comparer)

CommandLineSwitches.cs (2)

320if (string.Equals(switchName, parameterlessSwitchName, StringComparison.OrdinalIgnoreCase)) 362if (string.Equals(switchName, parameterizedSwitchName, StringComparison.OrdinalIgnoreCase))

CommunicationsUtilities.cs (5)

631if (runtimeVersion.Equals(XMakeAttributes.MSBuildRuntimeValues.clr2, StringComparison.OrdinalIgnoreCase)) 635else if (runtimeVersion.Equals(XMakeAttributes.MSBuildRuntimeValues.clr4, StringComparison.OrdinalIgnoreCase)) 639else if (runtimeVersion.Equals(XMakeAttributes.MSBuildRuntimeValues.net, StringComparison.OrdinalIgnoreCase)) 654if (architectureFlagToSet.Equals(XMakeAttributes.MSBuildArchitectureValues.x64, StringComparison.OrdinalIgnoreCase)) 658else if (architectureFlagToSet.Equals(XMakeAttributes.MSBuildArchitectureValues.arm64, StringComparison.OrdinalIgnoreCase))

ConversionUtilities.cs (12)

ErrorUtilities.cs (1)

105if (String.Equals(param.GetType().ToString(), param.ToString(), StringComparison.Ordinal))

FileUtilities.cs (9)

65internal static readonly StringComparison PathComparison = GetIsFileSystemCaseSensitive() ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase; 581var comparisonType = StringComparison.Ordinal; 834StringComparison pathComparison = alwaysIgnoreCase ? StringComparison.OrdinalIgnoreCase : PathComparison; 1540if (string.Compare(strA, i, strB, i, length, StringComparison.OrdinalIgnoreCase) == 0) 1548if (string.Compare(slash1, i, slash2, i, length, StringComparison.OrdinalIgnoreCase) == 0)

LoadedType.cs (2)

141if (String.Equals("Microsoft.Build.Tasks.Xaml.PartialClassGenerationTask", Type.FullName, StringComparison.OrdinalIgnoreCase)) 147if (String.Equals(assemblyName.Name, "PresentationBuildTasks", StringComparison.OrdinalIgnoreCase))

Modifiers.cs (15)

MSBuildNameIgnoreCaseComparer.cs (1)

68return compareToString.AsSpan().Equals(constrainedString.AsSpan(start, lengthToCompare), StringComparison.OrdinalIgnoreCase);

OutOfProcTaskHostNode.cs (7)

908_debugCommunications = taskConfiguration.BuildProcessEnvironment.ContainsValueAndIsEqual("MSBUILDDEBUGCOMM", "1", StringComparison.OrdinalIgnoreCase); 909_updateEnvironment = !taskConfiguration.BuildProcessEnvironment.ContainsValueAndIsEqual("MSBuildTaskHostDoNotUpdateEnvironment", "1", StringComparison.OrdinalIgnoreCase); 910_updateEnvironmentAndLog = taskConfiguration.BuildProcessEnvironment.ContainsValueAndIsEqual("MSBuildTaskHostUpdateEnvironmentAndLog", "1", StringComparison.OrdinalIgnoreCase); 1042if (String.Equals(environmentValue, oldValue, StringComparison.OrdinalIgnoreCase)) 1109if (String.Equals(environmentValue, oldValue, StringComparison.OrdinalIgnoreCase)) 1162if (!String.Equals(oldValue, newValue, StringComparison.OrdinalIgnoreCase)) 1179if (!String.Equals(oldValue, newValue, StringComparison.OrdinalIgnoreCase))

PrintLineDebuggerWriters.cs (1)

78var logIndex = executingAssembly.IndexOf(binPart, StringComparison.Ordinal);

ResourceUtilities.cs (1)

435if (string.Equals(param.GetType().ToString(), param.ToString(), StringComparison.Ordinal) &&

StringExtensions.cs (1)

16public static string Replace(this string aString, string oldValue, string newValue, StringComparison stringComparison)

TypeLoader.cs (2)

116if (longerTypeName.EndsWith(shorterTypeName, StringComparison.OrdinalIgnoreCase)) 147isPartialMatch = (String.Equals(typeName1, typeName2, StringComparison.OrdinalIgnoreCase));

XMake.cs (56)

XMakeAttributes.cs (40)

AssemblyNameExtension.cs (9)

BuildEnvironmentHelper.cs (5)

360directory.EndsWith(@"\amd64", StringComparison.OrdinalIgnoreCase) || 361directory.EndsWith(@"\arm64", StringComparison.OrdinalIgnoreCase) 423processFileName.Equals(s, StringComparison.OrdinalIgnoreCase)); 594if (string.Equals(currentToolsDirectory.Name, "amd64", StringComparison.OrdinalIgnoreCase) || 595string.Equals(currentToolsDirectory.Name, "arm64", StringComparison.OrdinalIgnoreCase))

CollectionHelpers.cs (1)

41internal static bool ContainsValueAndIsEqual(this Dictionary<string, string> dictionary, string key, string value, StringComparison comparer)

CommunicationsUtilities.cs (5)

631if (runtimeVersion.Equals(XMakeAttributes.MSBuildRuntimeValues.clr2, StringComparison.OrdinalIgnoreCase)) 635else if (runtimeVersion.Equals(XMakeAttributes.MSBuildRuntimeValues.clr4, StringComparison.OrdinalIgnoreCase)) 639else if (runtimeVersion.Equals(XMakeAttributes.MSBuildRuntimeValues.net, StringComparison.OrdinalIgnoreCase)) 654if (architectureFlagToSet.Equals(XMakeAttributes.MSBuildArchitectureValues.x64, StringComparison.OrdinalIgnoreCase)) 658else if (architectureFlagToSet.Equals(XMakeAttributes.MSBuildArchitectureValues.arm64, StringComparison.OrdinalIgnoreCase))

D\a\_work\1\s\bin\repo\msbuild\src\Shared\ErrorUtilities.cs\ErrorUtilities.cs (1)

105if (String.Equals(param.GetType().ToString(), param.ToString(), StringComparison.Ordinal))

EnvironmentUtilities.cs (3)

101return propertyName.StartsWith("MSBUILD", StringComparison.OrdinalIgnoreCase) || 102propertyName.StartsWith("COMPLUS_", StringComparison.OrdinalIgnoreCase) || 103propertyName.StartsWith("DOTNET_", StringComparison.OrdinalIgnoreCase);

FileUtilities.cs (9)

65internal static readonly StringComparison PathComparison = GetIsFileSystemCaseSensitive() ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase; 530if (!NativeMethodsShared.IsWindows || !path.StartsWith(@"\\", StringComparison.Ordinal)) 560return isUNC || path.IndexOf(@"\\?\globalroot", StringComparison.OrdinalIgnoreCase) != -1; 834StringComparison pathComparison = alwaysIgnoreCase ? StringComparison.OrdinalIgnoreCase : PathComparison; 1540if (string.Compare(strA, i, strB, i, length, StringComparison.OrdinalIgnoreCase) == 0) 1548if (string.Compare(slash1, i, slash2, i, length, StringComparison.OrdinalIgnoreCase) == 0)

LoadedType.cs (2)

141if (String.Equals("Microsoft.Build.Tasks.Xaml.PartialClassGenerationTask", Type.FullName, StringComparison.OrdinalIgnoreCase)) 147if (String.Equals(assemblyName.Name, "PresentationBuildTasks", StringComparison.OrdinalIgnoreCase))

Modifiers.cs (15)

NodeEndpointOutOfProcBase.cs (1)

438if (clientIdentity == null || !String.Equals(clientIdentity.Name, currentIdentity.Name, StringComparison.OrdinalIgnoreCase))

OutOfProcTaskHostNode.cs (7)

908_debugCommunications = taskConfiguration.BuildProcessEnvironment.ContainsValueAndIsEqual("MSBUILDDEBUGCOMM", "1", StringComparison.OrdinalIgnoreCase); 909_updateEnvironment = !taskConfiguration.BuildProcessEnvironment.ContainsValueAndIsEqual("MSBuildTaskHostDoNotUpdateEnvironment", "1", StringComparison.OrdinalIgnoreCase); 910_updateEnvironmentAndLog = taskConfiguration.BuildProcessEnvironment.ContainsValueAndIsEqual("MSBuildTaskHostUpdateEnvironmentAndLog", "1", StringComparison.OrdinalIgnoreCase); 1042if (String.Equals(environmentValue, oldValue, StringComparison.OrdinalIgnoreCase)) 1109if (String.Equals(environmentValue, oldValue, StringComparison.OrdinalIgnoreCase)) 1162if (!String.Equals(oldValue, newValue, StringComparison.OrdinalIgnoreCase)) 1179if (!String.Equals(oldValue, newValue, StringComparison.OrdinalIgnoreCase))

ResourceUtilities.cs (1)

435if (string.Equals(param.GetType().ToString(), param.ToString(), StringComparison.Ordinal) &&

TaskLoader.cs (1)

182if (args.Name.Equals(s_resolverLoadedType?.LoadedAssemblyName?.FullName, StringComparison.OrdinalIgnoreCase))

Traits.cs (8)

184(value.Equals("1", StringComparison.OrdinalIgnoreCase) || 185value.Equals("true", StringComparison.OrdinalIgnoreCase)); 292_logPropertiesAndItemsAfterEvaluation = variable == "1" || string.Equals(variable, "true", StringComparison.OrdinalIgnoreCase); 466if (mode.Equals("full", StringComparison.OrdinalIgnoreCase)) 471if (mode.Equals("partial", StringComparison.OrdinalIgnoreCase)) 494const StringComparison comparison = StringComparison.OrdinalIgnoreCase; 587if (string.Equals(param.GetType().ToString(), param.ToString(), StringComparison.Ordinal) &&

TypeLoader.cs (2)

89if (longerTypeName.EndsWith(shorterTypeName, StringComparison.OrdinalIgnoreCase)) 120isPartialMatch = (String.Equals(typeName1, typeName2, StringComparison.OrdinalIgnoreCase));

XMakeAttributes.cs (40)

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

1086[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.StringComparison))]

src\Shared\AnalyzerTesting\TestReferences.cs (4)

46if (!name.StartsWith("Microsoft.Extensions", StringComparison.Ordinal) && 47!name.StartsWith("Microsoft.AspNetCore", StringComparison.Ordinal) && 48!name.StartsWith("System", StringComparison.Ordinal) && 49!name.StartsWith("netstandard", StringComparison.Ordinal))

Infrastructure\MvcDiagnosticAnalyzerRunner.cs (1)

37if (!project.MetadataReferences.Any(c => string.Equals(Path.GetFileNameWithoutExtension(c.Display), Path.GetFileNameWithoutExtension(assembly), StringComparison.OrdinalIgnoreCase)))

StartupForDynamic.cs (1)

56var split = kvp.Replace("%2F", "/", StringComparison.OrdinalIgnoreCase).Split("=");

StartupForDynamicAndRazorPages.cs (1)

47var split = kvp.Replace("%2F", "/", StringComparison.OrdinalIgnoreCase).Split("=");

StartupForDynamicOrder.cs (1)

109var split = kvp.Replace("%2F", "/", StringComparison.OrdinalIgnoreCase).Split("=");

Components\NavigationManagerExtensions.cs (1)

9if (uri.StartsWith(navigationManager.BaseUri, StringComparison.Ordinal))

Program.cs (1)

19if (string.Equals("HttpSys", webBuilder.GetSetting("server"), StringComparison.OrdinalIgnoreCase))

netstandard.cs (1)

2020[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.StringComparison))]

MinimizeUtil.cs (1)

85if (fileName.EndsWith(".dll", StringComparison.Ordinal) && TryGetMvid(sourceFilePath, out var mvid))

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

329if (!string.Equals(localizableString, "false", StringComparison.OrdinalIgnoreCase))

Microsoft\Build\Tasks\Windows\GenerateTemporaryTargetAssembly.cs (4)

84if (!string.Equals(IncludePackageReferencesDuringMarkupCompilation, "false", StringComparison.OrdinalIgnoreCase)) 629if (root.ChildNodes[i] is XmlElement nodeGroup && string.Equals(nodeGroup.Name, groupName, StringComparison.OrdinalIgnoreCase)) 640if (nodeGroup.ChildNodes[j] is XmlElement nodeItem && string.Equals(nodeItem.Name, sItemName, StringComparison.OrdinalIgnoreCase)) 799if (xmlAttribute.Name.Equals("Sdk", StringComparison.OrdinalIgnoreCase))

Microsoft\Build\Tasks\Windows\MarkupCompilePass1.cs (3)

264if (!_outputDir.EndsWith(string.Empty + Path.DirectorySeparatorChar, StringComparison.Ordinal)) 1534if (string.Equals(localTypeXamlFile, xamlInputFullPath, StringComparison.OrdinalIgnoreCase)) 1711if (!string.Equals(strLocalizable, "false", StringComparison.OrdinalIgnoreCase))

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

243if (!_outputPath.EndsWith(string.Empty + Path.DirectorySeparatorChar, StringComparison.Ordinal))

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

254if (!_outputPath.EndsWith((Path.DirectorySeparatorChar).ToString(), StringComparison.Ordinal))

MS\Internal\MarkupCompiler\MarkupCompiler.cs (9)

MS\Internal\MarkupCompiler\ParserExtension.cs (1)

497_isInternalRoot = !string.Equals("public", xmlReader.Value.Trim(), StringComparison.OrdinalIgnoreCase);

MS\Internal\MarkupCompiler\PathInternal.cs (5)

26internal static string GetRelativePath(string relativeTo, string path, StringComparison comparisonType) 40Debug.Assert(comparisonType == StringComparison.Ordinal || comparisonType == StringComparison.OrdinalIgnoreCase); 49int commonLength = PathInternal.GetCommonPathLength(relativeTo, path, ignoreCase: comparisonType == StringComparison.OrdinalIgnoreCase); 157internal static bool AreRootsEqual(string first, string second, StringComparison comparisonType)

MS\Internal\Shared\SourceFileInfo.cs (1)

43if (!string.IsNullOrEmpty(file.Path) && file.Path.ToUpperInvariant().EndsWith(XAML, StringComparison.Ordinal))

MS\Internal\Tasks\CompilerWrapper.cs (2)

259if (string.Equals(asmReference.AssemblyName, assemblyName, StringComparison.OrdinalIgnoreCase)) 402if (fullFilePath.StartsWith(_sourceDir,StringComparison.OrdinalIgnoreCase))

MS\Internal\Tasks\IncrementalCompileAnalyzer.cs (2)

348IsSettingModified = !string.Equals(textSource, textTarget, StringComparison.OrdinalIgnoreCase); 424if (string.Equals(xamlfile.Path, CompilerLocalReference.LocalMarkupPages[j].FilePath, StringComparison.OrdinalIgnoreCase))

MS\Internal\Tasks\TaskHelper.cs (3)

102if (fullpath2.StartsWith(fullpath1, StringComparison.OrdinalIgnoreCase)) 199if (!e.Message.Contains(eInner.Message, StringComparison.Ordinal)) 210if (message != null && !message.EndsWith(".", StringComparison.Ordinal))

src\Microsoft.DotNet.Wpf\src\Common\src\System\SR.cs (1)

55if (defaultString is not null && resourceKey.Equals(resourceString, StringComparison.Ordinal))

src\Microsoft.DotNet.Wpf\src\PresentationCore\System\Windows\Media\Knowncolors.cs (141)

src\Microsoft.DotNet.Wpf\src\PresentationFramework\MS\Internal\Globalization\LocalizationComments.cs (2)

354if (enumName.StartsWith(_enumPrefix, StringComparison.Ordinal)) 362if (string.Equals(enumName, _enumNames[i], StringComparison.Ordinal))

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

682if (!xamlXmlnsPropertyNode.XmlNamespace.StartsWith(XamlReaderHelper.MappingProtocol, StringComparison.Ordinal))

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\KnownTypes.cs (471)

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

1157if (xmlNamespace.StartsWith(XamlReaderHelper.MappingProtocol, StringComparison.Ordinal))

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\XamlReaderHelper.cs (8)

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\XamlTypeMapper.cs (6)

346int indexComma = assemblyName.IndexOf(",", StringComparison.Ordinal); 390if (AssemblyWB == null && string.Equals(asmName, _assemblyNames[0], StringComparison.OrdinalIgnoreCase)) 394else if (AssemblyPC == null && string.Equals(asmName, _assemblyNames[1], StringComparison.OrdinalIgnoreCase)) 398else if (AssemblyPF == null && string.Equals(asmName, _assemblyNames[2], StringComparison.OrdinalIgnoreCase)) 402else if (string.Equals(asmName, "SYSTEM.XML", StringComparison.OrdinalIgnoreCase)) 407else if (string.Equals(asmName, "SYSTEM", StringComparison.OrdinalIgnoreCase))

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

221if(string.Equals(cinfo.ReflectedType.FullName, fullClrName, StringComparison.Ordinal))

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

59int escapedComma = fullName.LastIndexOf("\\,", StringComparison.Ordinal);

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

70if (sourcePath.StartsWith(basePath, StringComparison.OrdinalIgnoreCase))

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\Xaml\Parser\SpecialBracketCharacters.cs (2)

109return _endChars.IndexOf(end.ToString(), StringComparison.Ordinal) == _startChars.IndexOf(start.ToString(), StringComparison.Ordinal);

src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\XmlCompatibilityReader.cs (2)

649if (string.Equals(XmlnsDeclaration, Reader.LocalName, StringComparison.Ordinal)) 655else if (string.Equals(XmlnsDeclaration, Reader.Prefix, StringComparison.Ordinal))

MS\Internal\AppModel\CookieHandler.cs (1)

78if (string.Equals(headers.Keys[i], "Set-Cookie", StringComparison.OrdinalIgnoreCase))

MS\Internal\AppModel\SiteOfOriginPart.cs (1)

141if (string.Equals(_absoluteLocation.Scheme, Uri.UriSchemeFile, StringComparison.OrdinalIgnoreCase))

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

71if (string.Equals((localPath.Length > 0 && localPath[localPath.Length - 1] != Path.DirectorySeparatorChar) ? localPath + Path.DirectorySeparatorChar : localPath, Util.WindowsFontsUriObject.LocalPath, StringComparison.OrdinalIgnoreCase))

MS\Internal\FontCache\FamilyCollection.cs (4)

128if (string.Equals(familyName, _legacyArabicFonts[i], StringComparison.OrdinalIgnoreCase)) 257if (string.Equals(_systemCompositeFontsNames[i], familyName, StringComparison.OrdinalIgnoreCase)) 435if (string.Equals(localizedFamilyName.Value, familyName, StringComparison.OrdinalIgnoreCase)) 461if (faceName.Equals(name.Value, StringComparison.OrdinalIgnoreCase))

MS\Internal\FontCache\FontCacheUtil.cs (3)

526if (string.Equals(extension, supportedExtension, StringComparison.OrdinalIgnoreCase)) 538return (string.Equals(extension, CompositeFontExtension, StringComparison.OrdinalIgnoreCase)); 941return string.Compare(x._language.IetfLanguageTag, y._language.IetfLanguageTag, StringComparison.OrdinalIgnoreCase);

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

72Debug.Assert(escapedPath.EndsWith(FakeFileName, StringComparison.OrdinalIgnoreCase));

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

186if (string.Equals(response.ContentType, ObfuscatedContentType, StringComparison.Ordinal)) 262if (String.Equals(response.ContentType, ObfuscatedContentType, StringComparison.Ordinal))

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

192catch (Exception x) when(string.Equals(x.GetType().FullName, "System.Security.XmlSyntaxException", StringComparison.OrdinalIgnoreCase))

MS\Internal\IO\Packaging\ByteRangeDownloader.cs (4)

402if (!string.Equals(requestedUri.Scheme, Uri.UriSchemeHttp, StringComparison.Ordinal) && !string.Equals(requestedUri.Scheme, Uri.UriSchemeHttps, StringComparison.Ordinal)) 762|| !contentRange.StartsWith(ByteRangeUnit, StringComparison.Ordinal)) 795if (!contentRangeSpan.Equals("*", StringComparison.Ordinal))

MS\Internal\IO\Packaging\NetStream.cs (2)

92if (fullStreamLength > 0 && ((string.Equals(uri.Scheme, Uri.UriSchemeHttp, StringComparison.Ordinal)) || 93(string.Equals(uri.Scheme, Uri.UriSchemeHttps, StringComparison.Ordinal))))

MS\Internal\IO\Packaging\PseudoWebRequest.cs (1)

326return (string.Equals(_innerUri.Scheme, schemeName, StringComparison.Ordinal));

MS\Internal\WpfWebRequestHelper.cs (3)

50if (string.Equals(uri.Scheme, PackUriHelper.UriSchemePack, StringComparison.Ordinal)) 258if (string.Equals(extension, MimeTypeMapper.XamlExtension, StringComparison.OrdinalIgnoreCase) || 259string.Equals(extension, MimeTypeMapper.XbapExtension, StringComparison.OrdinalIgnoreCase))

src\Microsoft.DotNet.Wpf\src\Common\src\System\SR.cs (1)

55if (defaultString is not null && resourceKey.Equals(resourceString, StringComparison.Ordinal))

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

115if (string.Equals(curAsmName.Name, assemblyName.Name, StringComparison.InvariantCultureIgnoreCase) &&

src\Microsoft.DotNet.Wpf\src\Shared\MS\Utility\BindUriHelper.cs (1)

81return string.Equals(first.Scheme, second.Scheme, StringComparison.OrdinalIgnoreCase) && string.Equals(first.Host, second.Host);

System\IO\Packaging\PackWebRequestFactory.cs (2)

59if (!string.Equals(uri.Scheme, PackUriHelper.UriSchemePack, StringComparison.Ordinal)) 137if (string.Equals(uri.Scheme, PackUriHelper.UriSchemePack, StringComparison.Ordinal))

System\Windows\DurationConverter.cs (2)

56if (valueSpan.Equals("Automatic", StringComparison.Ordinal)) 58else if (valueSpan.Equals("Forever", StringComparison.Ordinal))

System\Windows\FontStretches.cs (10)

System\Windows\FontStyles.cs (3)

33if (s.Equals("Normal", StringComparison.OrdinalIgnoreCase)) 38if (s.Equals("Italic", StringComparison.OrdinalIgnoreCase)) 43if (s.Equals("Oblique", StringComparison.OrdinalIgnoreCase))

System\Windows\FontWeights.cs (16)

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

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

220if (string.Equals(e.PropertyName, "MouseAction", StringComparison.Ordinal))

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

55(cursorFile.EndsWith(".cur", StringComparison.OrdinalIgnoreCase) || 56cursorFile.EndsWith(".ani", StringComparison.OrdinalIgnoreCase)))

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

170if (text.EndsWith(".cur", StringComparison.OrdinalIgnoreCase) || text.EndsWith(".ani", StringComparison.OrdinalIgnoreCase))

System\Windows\Input\Stylus\Wisp\WispTabletDeviceCollection.cs (1)

109if (sValDefault != null && sValDefault.LastIndexOf(valueToSearchFor, StringComparison.OrdinalIgnoreCase) != -1)

System\Windows\InterOp\HwndSourceParameters.cs (1)

422if (ReflectionUtils.GetAssemblyPartialName(Assembly.GetEntryAssembly()).Equals("drthwndsource", StringComparison.CurrentCultureIgnoreCase))

System\Windows\Markup\XmlLanguage.cs (3)

186if(string.Equals(lowerCaseTag, "und", StringComparison.Ordinal)) 226if (_lowerCaseTag.Length == 0 || string.Equals(_lowerCaseTag, "und", StringComparison.Ordinal)) 624if(!longTag.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))

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

102return String.Equals(x.ToString(), y.ToString(), StringComparison.OrdinalIgnoreCase);

System\Windows\Media\Imaging\BitmapDecoder.cs (1)

1019if (string.Equals(uri.Scheme, PackUriHelper.UriSchemePack, StringComparison.OrdinalIgnoreCase))

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

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

85if (!trimmedColor.StartsWith(s_ContextColor, StringComparison.OrdinalIgnoreCase)) 141if (!trimmedColor.StartsWith("sc#", StringComparison.Ordinal))

System\Windows\Media\PixelFormat.cs (27)

System\Windows\Navigation\BaseUriHelper.cs (14)

Microsoft\Win32\FileDialog.cs (1)

310if (!string.Equals(value, _filter, StringComparison.Ordinal)) // different filter than what we have stored already

MS\Internal\AppModel\AppModelKnownContentFactory.cs (2)

78if (string.Equals(baseUri.Scheme, BaseUriHelper.PackAppBaseUri.Scheme, StringComparison.OrdinalIgnoreCase)) 146if (string.Equals(baseUri.Scheme, BaseUriHelper.PackAppBaseUri.Scheme, StringComparison.OrdinalIgnoreCase))

MS\Internal\AppModel\AppSecurityManager.cs (1)

76bool fIsMailTo = string.Equals(destinationUri.Scheme, Uri.UriSchemeMailto, StringComparison.OrdinalIgnoreCase);

MS\Internal\AppModel\ResourcePart.cs (2)

116if (string.Equals(Path.GetExtension(_name), ResourceContainer.BamlExt, StringComparison.OrdinalIgnoreCase)) 121if (string.Equals(Path.GetExtension(_name), ResourceContainer.XamlExt, StringComparison.OrdinalIgnoreCase))

MS\Internal\AppModel\ReturnEventSaver.cs (1)

116if (!string.Equals(_returnList[i]._targetTypeName, caller.GetType().AssemblyQualifiedName, StringComparison.Ordinal))

MS\Internal\Controls\CustomCategoryAttribute.cs (5)

17Debug.Assert("Content".Equals(name, StringComparison.Ordinal) 18|| "Accessibility".Equals(name, StringComparison.Ordinal) 19|| "Navigation".Equals(name, StringComparison.Ordinal)); 25if (string.Equals(value, "Content", StringComparison.Ordinal)) 27else if (string.Equals(value, "Accessibility", StringComparison.Ordinal))

MS\Internal\Controls\WebBrowserEvent.cs (5)

75if ((_parent.NavigatingToAboutBlank) && !string.Equals(urlString, WebBrowser.AboutBlankUriString, StringComparison.OrdinalIgnoreCase)) 166Invariant.Assert(_parent.NavigatingToAboutBlank && string.Equals((string)url, WebBrowser.AboutBlankUriString, StringComparison.OrdinalIgnoreCase)); 194Invariant.Assert(string.Equals(urlString, WebBrowser.AboutBlankUriString, StringComparison.OrdinalIgnoreCase)); 222Invariant.Assert(string.Equals(urlString, WebBrowser.AboutBlankUriString, StringComparison.OrdinalIgnoreCase)); 239return _parent.NavigatingToAboutBlank && !string.Equals(urlString, WebBrowser.AboutBlankUriString, StringComparison.OrdinalIgnoreCase);

MS\Internal\Data\CollectionViewGroupRoot.cs (3)

663if (pgd.StringComparison == StringComparison.OrdinalIgnoreCase || 664pgd.StringComparison == StringComparison.InvariantCultureIgnoreCase) 668else if (pgd.StringComparison == StringComparison.CurrentCultureIgnoreCase)

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

442String.Equals(SVI[k].propertyName, propertyName, StringComparison.OrdinalIgnoreCase)))

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

805if (s.StartsWith("()", StringComparison.Ordinal))

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

652if (s.StartsWith("\"", StringComparison.Ordinal)) s = s.Substring(1);

MS\Internal\Globalization\LocalizationComments.cs (2)

354if (enumName.StartsWith(_enumPrefix, StringComparison.Ordinal)) 362if (string.Equals(enumName, _enumNames[i], StringComparison.Ordinal))

MS\Internal\Interop\InternalDispatchObject.cs (1)

116if (name.StartsWith("[DISPID=", StringComparison.OrdinalIgnoreCase))

MS\Internal\IO\Packaging\ContentDescriptor.cs (2)

43return ( string.Equals(BaseName, otherElement.BaseName, StringComparison.Ordinal) 44&& string.Equals(XmlNamespace, otherElement.XmlNamespace, StringComparison.Ordinal) );

MS\Internal\IO\Packaging\XamlFilter.cs (9)

MS\Internal\IO\Packaging\XmlGlyphRunInfo.cs (3)

39&& string.Equals(_glyphsNode.LocalName, _glyphRunName, StringComparison.Ordinal) 40&& string.Equals(_glyphsNode.NamespaceURI, ElementTableKey.FixedMarkupNamespace, StringComparison.Ordinal)); 176if (string.Equals(languageString.ToUpperInvariant(), _undeterminedLanguageStringUpper, StringComparison.Ordinal))

MS\Internal\Printing\PrintDlgExMarshaler.cs (1)

330if (printerName.Equals(queue.FullName, StringComparison.OrdinalIgnoreCase))

MS\Internal\Printing\Win32PrintDialog.cs (1)

105if (String.Equals(e.GetType().FullName, "System.Printing.PrintingNotSupportedException", StringComparison.Ordinal))

MS\Internal\TraceData.cs (1)

268if (name.EndsWith(suffix, StringComparison.Ordinal))

MS\Internal\Utility\BindUriHelper.cs (1)

140return uri.OriginalString.StartsWith(FRAGMENTMARKER, StringComparison.Ordinal);

MS\Internal\WindowsRuntime\Windows\Data\Text\WordsSegmenter.cs (1)

63if (ScriptCodesRequiringDedicatedSegmenter.FindIndex(s => s.Equals(script, StringComparison.InvariantCultureIgnoreCase)) == -1)

MS\Win32\UxThemeWrapper.cs (1)

265if(string.Equals(themeName, "aero", StringComparison.OrdinalIgnoreCase) && Utilities.IsOSWindows8OrNewer)

src\Microsoft.DotNet.Wpf\src\Common\src\MS\Internal\PixelUnit.cs (4)

19if (value.EndsWith("px", StringComparison.OrdinalIgnoreCase)) 33if (value.EndsWith("in", StringComparison.OrdinalIgnoreCase)) 47if (value.EndsWith("cm", StringComparison.OrdinalIgnoreCase)) 61if (value.EndsWith("pt", StringComparison.OrdinalIgnoreCase))

src\Microsoft.DotNet.Wpf\src\Common\src\System\SR.cs (1)

55if (defaultString is not null && resourceKey.Equals(resourceString, StringComparison.Ordinal))

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\Xaml\Parser\SpecialBracketCharacters.cs (2)

109return _endChars.IndexOf(end.ToString(), StringComparison.Ordinal) == _startChars.IndexOf(start.ToString(), StringComparison.Ordinal);

src\Microsoft.DotNet.Wpf\src\Shared\MS\Utility\BindUriHelper.cs (1)

81return string.Equals(first.Scheme, second.Scheme, StringComparison.OrdinalIgnoreCase) && string.Equals(first.Host, second.Host);

System\Windows\Application.cs (2)

2351if (string.Equals(fileInBamlConvert, fileCurrent, StringComparison.OrdinalIgnoreCase)) 2378if (string.Equals(bamlConvertUriSegments[l - 1], curUriSegments[m - 1], StringComparison.OrdinalIgnoreCase))

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

740if (!String.Equals(newText, matchedText, StringComparison.CurrentCulture))

System\Windows\Controls\DataGrid.cs (2)

7173if (string.Equals(Items.SortDescriptions[i].PropertyName, sortPropertyName, StringComparison.Ordinal) && 7321propertyGroupDescription.StringComparison == StringComparison.Ordinal)

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

210if ((string.Equals(propertyName, "Binding", StringComparison.Ordinal)) || 211(string.Equals(propertyName, "ElementStyle", StringComparison.Ordinal) && !isCellEditing) || 212(string.Equals(propertyName, "EditingElementStyle", StringComparison.Ordinal) && isCellEditing))

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

121if (element is DataGridCell cell && string.Equals(propertyName, "IsThreeState", StringComparison.Ordinal))

System\Windows\Controls\DataGridClipboardHelper.cs (4)

16bool csv = string.Equals(format, DataFormats.CommaSeparatedValue, StringComparison.OrdinalIgnoreCase); 17if (csv || string.Equals(format, DataFormats.Text, StringComparison.OrdinalIgnoreCase) 18|| string.Equals(format, DataFormats.UnicodeText, StringComparison.OrdinalIgnoreCase)) 42else if (string.Equals(format, DataFormats.Html, StringComparison.OrdinalIgnoreCase))

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

199else if (e.Property == DataGrid.HorizontalScrollOffsetProperty || string.Equals(propertyName, "ViewportWidth", StringComparison.Ordinal))

System\Windows\Controls\DataGridComboBoxColumn.cs (2)

411if ((string.Equals(propertyName, "ElementStyle", StringComparison.Ordinal) && !isCellEditing) || 412(string.Equals(propertyName, "EditingElementStyle", StringComparison.Ordinal) && isCellEditing))

System\Windows\Controls\DataGridHyperlinkColumn.cs (2)

110if (string.Equals(propertyName, "ContentBinding", StringComparison.Ordinal)) 114else if (string.Equals(propertyName, "TargetName", StringComparison.Ordinal))

System\Windows\Controls\DataGridLengthConverter.cs (2)

201if (valueSpan.Equals(unitString, StringComparison.OrdinalIgnoreCase)) 220if (valueSpan.EndsWith(unitString, StringComparison.OrdinalIgnoreCase))

System\Windows\Controls\DataGridTemplateColumn.cs (4)

209(string.Equals(propertyName, "CellTemplate", StringComparison.Ordinal) || 210string.Equals(propertyName, "CellTemplateSelector", StringComparison.Ordinal))) || 212(string.Equals(propertyName, "CellEditingTemplate", StringComparison.Ordinal) || 213string.Equals(propertyName, "CellEditingTemplateSelector", StringComparison.Ordinal))))

System\Windows\Controls\DatePicker.cs (2)

1198if (string.Equals(selectedDate, s, StringComparison.Ordinal)) 1234if (!string.Equals(Text, s, StringComparison.Ordinal))

System\Windows\Controls\Image.cs (2)

490return string.Equals(property, "Source", StringComparison.Ordinal); 498if (string.Equals(property, "Source", StringComparison.Ordinal))

System\Windows\Controls\ItemContainerGenerator.cs (2)

1122if (token.Equals(MS.Internal.PresentationFramework.BuildInfo.WCP_PUBLIC_KEY_TOKEN, StringComparison.OrdinalIgnoreCase) || 1123token.Equals(MS.Internal.PresentationFramework.BuildInfo.DEVDIV_PUBLIC_KEY_TOKEN, StringComparison.OrdinalIgnoreCase))

System\Windows\Controls\Primitives\DataGridCellsPresenter.cs (4)

389string.Equals(propertyName, "ViewportWidth", StringComparison.Ordinal) || 390string.Equals(propertyName, "DelayedColumnWidthComputation", StringComparison.Ordinal)) 394else if (string.Equals(propertyName, "RealizedColumnsBlockListForNonVirtualizedRows", StringComparison.Ordinal)) 398else if (string.Equals(propertyName, "RealizedColumnsBlockListForVirtualizedRows", StringComparison.Ordinal))

System\Windows\Controls\Primitives\DataGridColumnHeadersPresenter.cs (4)

299string.Equals(propertyName, "ViewportWidth", StringComparison.Ordinal) || 300string.Equals(propertyName, "DelayedColumnWidthComputation", StringComparison.Ordinal)) 309else if (string.Equals(propertyName, "RealizedColumnsBlockListForNonVirtualizedRows", StringComparison.Ordinal)) 313else if (string.Equals(propertyName, "RealizedColumnsBlockListForVirtualizedRows", StringComparison.Ordinal))

System\Windows\Controls\Primitives\Popup.cs (1)

3215if (string.Equals(sb.ToString(), WebOCWindowClassName, StringComparison.OrdinalIgnoreCase))

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

1691int index = newText.IndexOf(oldText, StringComparison.Ordinal);

System\Windows\Data\PropertyGroupDescription.cs (5)

96StringComparison stringComparison) 149[DefaultValue(StringComparison.Ordinal)] 150public StringComparison StringComparison 268private StringComparison _stringComparison = StringComparison.Ordinal;

System\Windows\DeferrableContent.cs (1)

38assemblyTargetsFramework2 = schemaContext.LocalAssembly.ImageRuntimeVersion.StartsWith("v2", StringComparison.Ordinal);

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

867if (baseUri.Scheme.Equals(PackUriHelper.UriSchemePack, StringComparison.OrdinalIgnoreCase)) 895if (baseUri.Scheme.Equals(PackUriHelper.UriSchemePack, StringComparison.OrdinalIgnoreCase))

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

396bool isSideways = string.Equals(sidewaysString, "True", StringComparison.OrdinalIgnoreCase);

System\Windows\Documents\FixedSchema.cs (13)

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

431charIndex = s.IndexOf(" ", charIndex+1, s.Length - charIndex -1, StringComparison.Ordinal);

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

1664if (addSpace && run.Text.Length>0 && !run.Text.EndsWith(" ", StringComparison.Ordinal) && !IsHyphen(run.Text[run.Text.Length - 1]))

System\Windows\Documents\RtfToXamlReader.cs (7)

3742if (string.Equals(lhs_tag, rhs_tag, StringComparison.OrdinalIgnoreCase)) 3754if (s.Equals(rhs_name, StringComparison.OrdinalIgnoreCase)) 8123if (instructionName.IndexOf("HYPERLINK", StringComparison.Ordinal) == 0) 8127else if (instructionName.IndexOf("SYMBOL", StringComparison.Ordinal) == 0) 8131else if (instructionName.IndexOf("INCLUDEPICTURE", StringComparison.Ordinal) == 0) 8168int uriSourceIndex = dnImage.Xaml.IndexOf("UriSource=", StringComparison.Ordinal); 8329int uriIndex = instructionName.IndexOf("http:", StringComparison.OrdinalIgnoreCase);

System\windows\Documents\TextEditor.cs (2)

473if (!String.Equals(inputCultureInfo.IetfLanguageTag, language.IetfLanguageTag, StringComparison.OrdinalIgnoreCase)) 1231int endOfFirstLine = textData.IndexOf(Environment.NewLine, StringComparison.Ordinal);

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

1350bool pastedFragmentEndsWithNewLine = textData.EndsWith("\n", StringComparison.Ordinal);

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

1936if (propertyType == typeof(double) && string.Equals(stringValue, "NaN", StringComparison.OrdinalIgnoreCase))

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

1363!string.Equals(compositionText, _lastCompositionText, StringComparison.Ordinal)) 4994int dotIndex = filename.LastIndexOf(".", StringComparison.Ordinal);

System\Windows\Documents\WpfPayload.cs (6)

535if (imageUriString.EndsWith(ImageBmpFileExtension, StringComparison.OrdinalIgnoreCase)) 539else if (imageUriString.EndsWith(ImageGifFileExtension, StringComparison.OrdinalIgnoreCase)) 543else if (imageUriString.EndsWith(ImageJpegFileExtension, StringComparison.OrdinalIgnoreCase) || imageUriString.EndsWith(ImageJpgFileExtension, StringComparison.OrdinalIgnoreCase)) 547else if (imageUriString.EndsWith(ImageTiffFileExtension, StringComparison.OrdinalIgnoreCase)) 700Invariant.Assert(imageSourceString.StartsWith("./", StringComparison.OrdinalIgnoreCase));

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

525if (string.Compare(xamlTag, xamlTag.Length, top, top.Length, top.Length, StringComparison.OrdinalIgnoreCase) == 0)

System\Windows\Documents\XamlToRtfWriter.cs (25)

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

163StringComparison.CurrentCultureIgnoreCase)) 172StringComparison.CurrentCultureIgnoreCase))

System\Windows\FrameworkElementFactory.cs (1)

1139return !childName.StartsWith(AutoGenChildNamePrefix, StringComparison.Ordinal);

System\Windows\LengthConverter.cs (1)

195if (valueSpan.Equals("auto", StringComparison.OrdinalIgnoreCase))

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

2066if (uriTypePrefix.Equals("clr-namespace", StringComparison.Ordinal)) 2087if (!keyword.Equals("assembly", StringComparison.Ordinal)) 2132if (xamlNs.StartsWith(XamlReaderHelper.MappingProtocol, StringComparison.Ordinal))

System\Windows\Markup\BamlMapTable.cs (6)

687return (ownerTypeId == -(short)knownElement && (string.Equals(propertyName, name, StringComparison.Ordinal))); 692return (record.OwnerTypeId == ownerTypeId) && (string.Equals(record.Name, name, StringComparison.Ordinal)); 701return (string.Equals(propertyName, name, StringComparison.Ordinal)); 1569if (!ownerAsm.FullName.StartsWith("PresentationFramework", StringComparison.OrdinalIgnoreCase) && 1570!ownerAsm.FullName.StartsWith("PresentationCore", StringComparison.OrdinalIgnoreCase) && 1571!ownerAsm.FullName.StartsWith("WindowsBase", StringComparison.OrdinalIgnoreCase))

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

2648(assemblyFullName.StartsWith("PresentationFramework", StringComparison.Ordinal) 2649|| assemblyFullName.StartsWith("System.Xaml", StringComparison.Ordinal)))

System\Windows\Markup\KnownTypes.cs (471)

System\Windows\Markup\Primitives\ExtensionSimplifierMarkupObject.cs (1)

321if (typeName.EndsWith("Extension", StringComparison.Ordinal))

System\Windows\Markup\Primitives\MarkupWriter.cs (3)

472name.EndsWith("Extension", StringComparison.Ordinal)) 1040name.EndsWith("Extension", StringComparison.Ordinal)) 1636if (uri.StartsWith(clrUriPrefix, StringComparison.Ordinal))

System\Windows\Markup\RestrictiveXamlXmlReader.cs (2)

195bool isValidNamespace = type.Namespace != null && (type.Namespace.Equals("System.Windows", StringComparison.Ordinal) || type.Namespace.StartsWith("System.Windows.", StringComparison.Ordinal));

System\Windows\Markup\XamlFigureLengthSerializer.cs (2)

192if (valueSpan.Equals(UnitStrings[i].Name, StringComparison.OrdinalIgnoreCase)) 203if (valueSpan.EndsWith(UnitStrings[i].Name, StringComparison.OrdinalIgnoreCase))

System\Windows\Markup\XamlGridLengthSerializer.cs (2)

192if (valueSpan.Equals(UnitStrings[i], StringComparison.OrdinalIgnoreCase)) 203if (valueSpan.EndsWith(UnitStrings[i], StringComparison.OrdinalIgnoreCase))

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

290if (-1 == xamlFilePath.LastIndexOf(XamlExt, StringComparison.Ordinal))

System\Windows\Markup\XamlTypeMapper.cs (2)

2877if (string.Equals(xmlns, XamlReaderHelper.DefaultNamespaceURI, StringComparison.Ordinal)) 3178if (xmlNamespace.StartsWith(XamlReaderHelper.MappingProtocol, StringComparison.Ordinal))

System\Windows\Markup\XamlTypeMapperSchemaContext.cs (3)

255int clrNsIndex = xmlNamespace.IndexOf(XamlReaderHelper.MappingProtocol, StringComparison.Ordinal); 265int assemblyIndex = xmlNamespace.IndexOf(XamlReaderHelper.MappingAssembly, StringComparison.Ordinal); 363if (xamlNamespace.StartsWith(XamlReaderHelper.MappingProtocol, StringComparison.Ordinal))

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

355if (string.Equals(xmlnsRequested, xmlns, StringComparison.Ordinal))

System\Windows\Navigation\JournalEntry.cs (1)

325if (string.Equals(uri.Scheme, PackUriHelper.UriSchemePack, StringComparison.OrdinalIgnoreCase))

System\Windows\Navigation\NavigationService.cs (2)

215isSame = isSame && string.Equals(aResolved.Fragment, bResolved.Fragment, StringComparison.OrdinalIgnoreCase); 672if (string.Equals(name, fe.Name, StringComparison.OrdinalIgnoreCase))

System\Windows\SystemResources.cs (1)

1090Debug.Assert(callerName.Equals(nameof(EnsureResourceChangeListener), StringComparison.InvariantCulture));

System\Windows\ThemeDictionaryExtension.cs (1)

105if (assemblyName.Equals(SystemResources.PresentationFrameworkName, StringComparison.OrdinalIgnoreCase))

System\Windows\ThemeManager.cs (4)

376if (sourceString.EndsWith(FluentLightDictionary, StringComparison.OrdinalIgnoreCase)) 380else if (sourceString.EndsWith(FluentDarkDictionary, StringComparison.OrdinalIgnoreCase)) 424StringComparison.OrdinalIgnoreCase)) 444StringComparison.OrdinalIgnoreCase))

System\Windows\ThemeMode.cs (1)

76public bool Equals(ThemeMode other) => string.Equals(Value, other.Value, StringComparison.Ordinal);

MS\Internal\Documents\Application\AddressUtility.cs (1)

30return mailtoUri is not null && string.Equals(mailtoUri.Scheme, Uri.UriSchemeMailto, StringComparison.OrdinalIgnoreCase);

MS\Internal\Documents\Application\CriticalFileToken.cs (1)

69StringComparison.OrdinalIgnoreCase);

MS\Internal\Documents\Application\DocumentProperties.cs (13)

MS\Internal\Documents\Application\DocumentStream.cs (1)

956XpsFileExtension, StringComparison.OrdinalIgnoreCase))

MS\Internal\Documents\Application\FilePresentation.cs (1)

87StringComparison.OrdinalIgnoreCase))

MS\Internal\Documents\Application\RestrictedTransactionalPackage.cs (6)

117StringComparison.OrdinalIgnoreCase)) || 121StringComparison.OrdinalIgnoreCase)) || 125StringComparison.OrdinalIgnoreCase)) || 129StringComparison.OrdinalIgnoreCase)) || 133StringComparison.OrdinalIgnoreCase)) || 137StringComparison.OrdinalIgnoreCase))

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

1870StringComparison.CurrentCultureIgnoreCase)) 1880StringComparison.CurrentCultureIgnoreCase))

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

918StringComparison.Ordinal);

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

57return userName.Equals(SR.RMPublishingAnyoneUserDisplay, StringComparison.OrdinalIgnoreCase); 217StringComparison.Ordinal)) 292if (GetUsernameFromRow(row).Equals(name, StringComparison.OrdinalIgnoreCase))

src\Microsoft.DotNet.Wpf\src\Common\src\System\SR.cs (1)

55if (defaultString is not null && resourceKey.Equals(resourceString, StringComparison.Ordinal))

Pages\ShortCircuitPageAtAuthFilter.cshtml.cs (1)

22&& string.Equals(expectedTargetName, currentTargetName, StringComparison.OrdinalIgnoreCase);

Pages\ShortCircuitPageAtPageFilter.cshtml.cs (1)

22&& string.Equals(expectedTargetName, currentTargetName, StringComparison.OrdinalIgnoreCase);

Services\TestBodyTagHelperComponent.cs (1)

36if (string.Equals(context.TagName, "body", StringComparison.Ordinal) &&

Services\TestHeadTagHelperComponent.cs (1)

14if (string.Equals(context.TagName, "head", StringComparison.Ordinal) && output.Attributes.ContainsName("inject"))

Packaging\XpsFixedPageReaderWriter.cs (5)

1854if (extension.Equals(XpsS0Markup.JpgExtension, StringComparison.OrdinalIgnoreCase)) 1858else if (extension.Equals(XpsS0Markup.PngExtension, StringComparison.OrdinalIgnoreCase)) 1862else if (extension.Equals(XpsS0Markup.TifExtension, StringComparison.OrdinalIgnoreCase)) 1866else if (extension.Equals(XpsS0Markup.WdpExtension, StringComparison.OrdinalIgnoreCase)) 1901if (string.Equals(extension, XpsS0Markup.ObfuscatedFontExt, StringComparison.OrdinalIgnoreCase))

Packaging\XpsManager.cs (6)

1113else if (contentKey.Equals("Dictionary", StringComparison.OrdinalIgnoreCase)) 1119else if (contentKey.Equals("Font", StringComparison.OrdinalIgnoreCase)) 1125else if (contentKey.Equals("ColorContext", StringComparison.OrdinalIgnoreCase)) 1131else if (contentKey.Equals("ResourceDictionary", StringComparison.OrdinalIgnoreCase)) 1137else if (contentKey.Equals("Image", StringComparison.OrdinalIgnoreCase)) 1219if (string.Equals(contentType.TypeComponent, "Image", StringComparison.OrdinalIgnoreCase))

PrintConfig\PrtCap_Reader.cs (2)

534int colonIndex = QName.IndexOf(":", StringComparison.Ordinal); 551int colonIndex = QName.IndexOf(":", StringComparison.Ordinal);

PrintConfig\PrtTicket_Editor.cs (3)

153if (attr.Name.StartsWith("xmlns:", StringComparison.Ordinal) || 420int colonIndex = QName.IndexOf(":", StringComparison.Ordinal); 433int colonIndex = QName.IndexOf(":", StringComparison.Ordinal);

Serialization\ColorTypeConverter.cs (1)

157if (colorString.StartsWith("sc#", StringComparison.Ordinal) && colorString.Contains('E'))

Serialization\Manager\ReachSerializationUtils.cs (1)

944return uri.OriginalString.StartsWith(FRAGMENTMARKER,StringComparison.Ordinal);

src\Microsoft.DotNet.Wpf\src\Common\src\System\SR.cs (1)

55if (defaultString is not null && resourceKey.Equals(resourceString, StringComparison.Ordinal))

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

65return String.Equals(a.ToString(), b.ToString(), StringComparison.Ordinal);

Replay.cs (2)

224var comparison = StringComparison.OrdinalIgnoreCase;

AbstractRunIterations`1.cs (2)

90if (name.EndsWith("Fact", StringComparison.Ordinal)) 97else if (name.EndsWith("FactAttribute", StringComparison.Ordinal))

DoNotCallGetTestAccessor.cs (6)

42if (!string.Equals(context.OwningSymbol.Name, TestAccessorHelper.GetTestAccessorMethodName, StringComparison.Ordinal) 43&& !string.Equals(context.OwningSymbol.ContainingType?.Name, TestAccessorHelper.TestAccessorTypeName, StringComparison.Ordinal)) 55if (string.Equals(memberReference.Member.ContainingType?.Name, TestAccessorHelper.TestAccessorTypeName, StringComparison.Ordinal)) 64if (invocation.TargetMethod.Name.Equals(TestAccessorHelper.GetTestAccessorMethodName, StringComparison.Ordinal)) 69else if (string.Equals(invocation.TargetMethod.ContainingType?.Name, TestAccessorHelper.TestAccessorTypeName, StringComparison.Ordinal)) 79if (objectCreation.Type!.Name.Equals(TestAccessorHelper.TestAccessorTypeName, StringComparison.Ordinal))

DoNotMixAttributesFromDifferentVersionsOfMEF.cs (1)

82.Where(ad => ad.AttributeClass.Name.Equals("MetadataAttributeAttribute", StringComparison.Ordinal));

src\RoslynAnalyzers\Utilities\Compiler\AdditionalFileProvider.cs (1)

43=> _additionalFiles.FirstOrDefault(x => Path.GetFileName(x.Path).Equals(fileName, StringComparison.OrdinalIgnoreCase));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

142var index = symbolName.LastIndexOf(".", StringComparison.OrdinalIgnoreCase);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\CompilationExtensions.cs (3)

35if (string.Equals(propertyValue?.Trim(), "true", StringComparison.OrdinalIgnoreCase)) 42(propertyValue.Contains(WebAppProjectGuidString, StringComparison.OrdinalIgnoreCase) || 43propertyValue.Contains(WebSiteProjectGuidString, StringComparison.OrdinalIgnoreCase)))

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (8)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IPropertySymbolExtensions.cs (1)

28|| !property.Name.Equals("IsCompleted", StringComparison.Ordinal)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (1)

840=> symbol?.Name.StartsWith("_", StringComparison.Ordinal) == true &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\StringExtensions.cs (1)

24return str.EndsWith(suffix, StringComparison.Ordinal);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\UriExtensions.cs (1)

38if (symbol.Name.Contains(word, StringComparison.OrdinalIgnoreCase))

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

403if (!genericInterfaceFullName.StartsWith("T:", StringComparison.Ordinal)) 478(optionValue == null || !optionValue.Contains(arg.optionForcedValue, StringComparison.Ordinal))) 505(optionValue == null || !optionValue.Contains(optionForcedValue, StringComparison.Ordinal)))

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (12)

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (2)

166if (xtext.Value.Contains("\r", StringComparison.Ordinal) || xtext.Value.Contains("\n", StringComparison.Ordinal))

src\RoslynAnalyzers\Utilities\Compiler\WordParser.cs (1)

250if (string.Equals(parsedWord, word, StringComparison.OrdinalIgnoreCase))

SymbolDeclaredEventMustBeGeneratedForSourceSymbols.cs (3)

113if (invocationSymbol.Name.Equals(SymbolDeclaredEventName, StringComparison.Ordinal) && 136!type.Name.Equals("Symbol", StringComparison.Ordinal)) 153namedType.Name.StartsWith("Source", StringComparison.Ordinal) &&

RelaxTestNamingSuppressorTests.cs (1)

123if (method.Name.EndsWith("Async", StringComparison.Ordinal))

CSharpAvoidOptSuffixForNullableEnableCode.cs (1)

69if (!identifier.Text.EndsWith(OptSuffix, StringComparison.Ordinal) ||

NumberCommentsRefactoring.cs (2)

66if (text.StartsWith("@\"", StringComparison.OrdinalIgnoreCase)) 71if (text.StartsWith("\"", StringComparison.OrdinalIgnoreCase))

RelativeDirectory.cs (1)

80var configurationIndex = _workingDir.IndexOf(configuration, StringComparison.CurrentCultureIgnoreCase);

OptionPages\InternalOptionsControl.cs (1)

55if (title.IndexOf(searchBox.Text, StringComparison.OrdinalIgnoreCase) < 0)

Options\VisualStudioOptionStorageTests.cs (2)

135Assert.False(configName.StartsWith(OptionDefinition.CSharpConfigNamePrefix, StringComparison.OrdinalIgnoreCase)); 136Assert.False(configName.StartsWith(OptionDefinition.VisualBasicConfigNamePrefix, StringComparison.OrdinalIgnoreCase));

Services\PerformanceTrackerServiceTests.cs (2)

139Assert.True(analyzerInfo.PIISafeAnalyzerId.IndexOf(analyzerName, StringComparison.OrdinalIgnoreCase) >= 0); 260return assembly.GetManifestResourceNames().Where(n => n.EndsWith(convert, StringComparison.OrdinalIgnoreCase)).First();

Services\ServiceHubServicesTests.cs (4)

1745var project = solution.Projects.First(p => string.Equals(p.Name, projectName, StringComparison.OrdinalIgnoreCase)); 1746var document = project.Documents.First(d => string.Equals(d.Name, documentName, StringComparison.OrdinalIgnoreCase)); 1753var project = solution.Projects.First(p => string.Equals(p.Name, projectName, StringComparison.OrdinalIgnoreCase)); 1755documentName => project.Documents.First(d => string.Equals(d.Name, documentName, StringComparison.OrdinalIgnoreCase)));

EndsWithStringRouteConstraint.cs (1)

26var endsWith = valueString.EndsWith(_endsWith, StringComparison.OrdinalIgnoreCase);

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (2)

166if (xtext.Value.Contains("\r", StringComparison.Ordinal) || xtext.Value.Contains("\n", StringComparison.Ordinal))

RulesetToEditorconfigConverterTests.cs (1)

27Assert.Contains("<Include ", rulesetText, StringComparison.OrdinalIgnoreCase);

AssemblyInfo.cs (1)

18return string.Compare(this.AssemblyPath, other.AssemblyPath, StringComparison.Ordinal);

ScenarioTestHelpers.cs (1)

42return String.Equals("localhost", serviceUri, StringComparison.OrdinalIgnoreCase);

Tcp\ClientCredentialTypeCertificateCanonicalNameTests.4.1.0.cs (3)

34bool shouldCallSucceed = string.Compare(localhostEndpointUri.Host, "localhost", StringComparison.OrdinalIgnoreCase) == 0; 110bool shouldCallSucceed = domainNameEndpointUri.Host.IndexOf('.') == -1 && string.Compare(domainNameEndpointUri.Host, "localhost", StringComparison.OrdinalIgnoreCase) != 0; 191if (string.Compare(domainNameHost, fqdnEndpointUri.Host, StringComparison.OrdinalIgnoreCase) != 0)

GenerateFilteredReferenceAssembliesTask.cs (1)

154apis.Sort(static (x, y) => x.AsSpan()[2..].CompareTo(y.AsSpan()[2..], StringComparison.Ordinal));

Program.cs (2)

32if (string.Equals(builder.GetSetting("server"), "Microsoft.AspNetCore.Server.HttpSys", StringComparison.OrdinalIgnoreCase)) 38"NtlmAuthentication", StringComparison.OrdinalIgnoreCase))

JsonSchemaExporter\JsonSchemaExporter.ReflectionHelpers.cs (1)

414public bool Equals(ParameterLookupKey other) => Type == other.Type && string.Equals(Name, other.Name, StringComparison.OrdinalIgnoreCase);

Throw\ThrowTest.cs (7)

21Assert.Contains(message, exception.Message, StringComparison.Ordinal); 32Assert.Contains(message, exception.Message, StringComparison.Ordinal); 42Assert.Contains(message, exception.Message, StringComparison.Ordinal); 55Assert.Contains(message, exception.Message, StringComparison.Ordinal); 74Assert.Contains(message, exception.Message, StringComparison.Ordinal); 92Assert.Contains(message, exception.Message, StringComparison.Ordinal); 104Assert.Contains(message, exception.Message, StringComparison.Ordinal);

Startup.cs (5)

81if (token.StartsWith("Bearer ", StringComparison.OrdinalIgnoreCase)) 221host.StartsWith("http://localhost:", StringComparison.Ordinal) 222|| host.StartsWith("http://127.0.0.1:", StringComparison.Ordinal) 223|| host.StartsWith("https://localhost:", StringComparison.Ordinal) 224|| host.StartsWith("https://127.0.0.1:", StringComparison.Ordinal))

PersistentConnectionLifeTimeManager.cs (1)

25if (string.Equals(format, "protobuf", StringComparison.OrdinalIgnoreCase))

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

314if (testUrl.StartsWith("https", StringComparison.Ordinal)) 522Assert.Single(LogMessages, log => log.LogLevel == LogLevel.Debug && string.Equals(CoreStrings.FormatBindingToDefaultAddress(Constants.DefaultServerAddress), log.Message, StringComparison.Ordinal)); 561log.Message.EndsWith(expectedMessage, StringComparison.Ordinal))); 596log.Message.EndsWith(expectedMessage, StringComparison.Ordinal))); 639log.Message, StringComparison.Ordinal)); 684log.Message, StringComparison.Ordinal)); 989log.Message.EndsWith(CoreStrings.FormatEndpointAlreadyInUse(thisAddressString), StringComparison.Ordinal)));

Startup.cs (4)

52return string.Equals(directory.FullName, basePath, StringComparison.OrdinalIgnoreCase) 53|| string.Equals(directory.FullName, usersPath, StringComparison.OrdinalIgnoreCase) 54|| string.Equals(directory.FullName, userPath, StringComparison.OrdinalIgnoreCase) 55|| directory.FullName.StartsWith(userPath + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase);

src\Shared\CommandLineUtils\CommandLine\AnsiConsole.cs (1)

66var escapeIndex = message.IndexOf("\x1b[", escapeScan, StringComparison.Ordinal);

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (8)

158if (arg.StartsWith("--", StringComparison.Ordinal)) 162else if (arg.StartsWith("-", StringComparison.Ordinal)) 171option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.LongName, longOptionName, StringComparison.Ordinal)); 250option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.ShortName, shortOption[0], StringComparison.Ordinal)); 274option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.SymbolName, shortOption[0], StringComparison.Ordinal)); 333if (string.Equals(subcommand.Name, arg, StringComparison.OrdinalIgnoreCase)) 449if (commandName == null || string.Equals(Name, commandName, StringComparison.OrdinalIgnoreCase)) 455target = Commands.SingleOrDefault(cmd => string.Equals(cmd.Name, commandName, StringComparison.OrdinalIgnoreCase));

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (4)

20if (part.StartsWith("--", StringComparison.Ordinal)) 24else if (part.StartsWith("-", StringComparison.Ordinal)) 38else if (part.StartsWith("<", StringComparison.Ordinal) && part.EndsWith(">", StringComparison.Ordinal))

src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

67if (string.Equals(expectedFileName, mainModuleFileName, StringComparison.OrdinalIgnoreCase))

SwaggathererApplication.cs (3)

196StringComparison.OrdinalIgnoreCase)) 203!string.Equals(entry.Method, other.Method, StringComparison.OrdinalIgnoreCase)) 230return string.Compare(x.Template.TemplateText, y.Template.TemplateText, StringComparison.Ordinal);

Microsoft\CSharp\CSharpCodeGenerator.cs (2)

1466if (e.Parameters.Count > 0 && string.Equals(e.Name, "Item", StringComparison.OrdinalIgnoreCase)) 2582if (current.Name.Equals("system.paramarrayattribute", StringComparison.OrdinalIgnoreCase))

Microsoft\VisualBasic\VBCodeGenerator.cs (6)

1561&& meth.Name.Equals(e.Name, StringComparison.OrdinalIgnoreCase) 1612if (e.ReturnType.BaseType.Length == 0 || string.Equals(e.ReturnType.BaseType, typeof(void).FullName, StringComparison.OrdinalIgnoreCase)) 1721&& prop.Name.Equals(e.Name, StringComparison.OrdinalIgnoreCase) 1765if (e.Parameters.Count > 0 && string.Equals(e.Name, "Item", StringComparison.OrdinalIgnoreCase)) 1957if (del.ReturnType.BaseType.Length > 0 && !string.Equals(del.ReturnType.BaseType, "System.Void", StringComparison.OrdinalIgnoreCase)) 1965if (del.ReturnType.BaseType.Length > 0 && !string.Equals(del.ReturnType.BaseType, "System.Void", StringComparison.OrdinalIgnoreCase))

Microsoft\VisualBasic\VBModifierAttributeConverter.cs (1)

27if (names[i].Equals(name, StringComparison.OrdinalIgnoreCase))

System\CodeDom\Compiler\CodeValidator.cs (1)

287if (e.Parameters.Count > 0 && string.Equals(e.Name, "Item", StringComparison.OrdinalIgnoreCase))

System\Collections\Frozen\String\Hashing.cs (1)

145return string.GetHashCode(s, StringComparison.OrdinalIgnoreCase);

System\Collections\Frozen\String\KeyAnalyzer.cs (2)

318public override bool Equals(string? x, string? y) => x.AsSpan(IsLeft ? Index : (x!.Length + Index), Count).Equals(y.AsSpan(IsLeft ? Index : (y!.Length + Index), Count), StringComparison.OrdinalIgnoreCase); 324public override bool Equals(string? x, string? y) => x.AsSpan(IsLeft ? Index : (x!.Length + Index), Count).Equals(y.AsSpan(IsLeft ? Index : (y!.Length + Index), Count), StringComparison.OrdinalIgnoreCase);

System\Collections\Frozen\String\OrdinalStringFrozenDictionary_FullCaseInsensitive.cs (1)

28private protected override bool Equals(ReadOnlySpan<char> x, string? y) => x.Equals(y.AsSpan(), StringComparison.OrdinalIgnoreCase);

System\Collections\Frozen\String\OrdinalStringFrozenDictionary_FullCaseInsensitiveAscii.cs (1)

28private protected override bool Equals(ReadOnlySpan<char> x, string? y) => x.Equals(y.AsSpan(), StringComparison.OrdinalIgnoreCase);

System\Collections\Frozen\String\OrdinalStringFrozenDictionary_LeftJustifiedCaseInsensitiveAsciiSubstring.cs (1)

26private protected override bool Equals(ReadOnlySpan<char> x, string? y) => x.Equals(y.AsSpan(), StringComparison.OrdinalIgnoreCase);

System\Collections\Frozen\String\OrdinalStringFrozenDictionary_LeftJustifiedCaseInsensitiveSubstring.cs (1)

26private protected override bool Equals(ReadOnlySpan<char> x, string? y) => x.Equals(y.AsSpan(), StringComparison.OrdinalIgnoreCase);

System\Collections\Frozen\String\OrdinalStringFrozenDictionary_RightJustifiedCaseInsensitiveAsciiSubstring.cs (1)

26private protected override bool Equals(ReadOnlySpan<char> x, string? y) => x.Equals(y.AsSpan(), StringComparison.OrdinalIgnoreCase);

System\Collections\Frozen\String\OrdinalStringFrozenDictionary_RightJustifiedCaseInsensitiveSubstring.cs (1)

26private protected override bool Equals(ReadOnlySpan<char> x, string? y) => x.Equals(y.AsSpan(), StringComparison.OrdinalIgnoreCase);

System\Collections\Frozen\String\OrdinalStringFrozenSet.cs (1)

109(!x.IsEmpty || y is not null) && x.Equals(y.AsSpan(), StringComparison.OrdinalIgnoreCase);

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

245.SingleOrDefault(m => string.Equals(m.Name, Method, StringComparison.Ordinal));

System\ComponentModel\DataAnnotations\PhoneAttribute.cs (3)

69.LastIndexOf(ExtensionAbbreviationExtDot, StringComparison.OrdinalIgnoreCase); 81.LastIndexOf(ExtensionAbbreviationExt, StringComparison.OrdinalIgnoreCase); 93.LastIndexOf(ExtensionAbbreviationX, StringComparison.OrdinalIgnoreCase);

System\ComponentModel\DataAnnotations\UrlAttribute.cs (3)

30return valueAsString.StartsWith("http://", StringComparison.OrdinalIgnoreCase) 31|| valueAsString.StartsWith("https://", StringComparison.OrdinalIgnoreCase) 32|| valueAsString.StartsWith("ftp://", StringComparison.OrdinalIgnoreCase);

System\ComponentModel\ComponentCollection.cs (1)

25if (comp != null && comp.Site != null && comp.Site.Name != null && string.Equals(comp.Site.Name, name, StringComparison.OrdinalIgnoreCase))

src\libraries\Common\src\System\Drawing\ColorConverterCommon.cs (2)

99else if (text.StartsWith("0x", StringComparison.OrdinalIgnoreCase) || text.StartsWith("&h", StringComparison.OrdinalIgnoreCase))

System\ComponentModel\BaseNumberConverter.cs (2)

65else if (AllowHex && (text.StartsWith("0x", StringComparison.OrdinalIgnoreCase) 66|| text.StartsWith("&h", StringComparison.OrdinalIgnoreCase)))

System\ComponentModel\ComponentResourceManager.cs (1)

146if (string.Compare(key, 0, objectName, 0, objectName.Length, StringComparison.OrdinalIgnoreCase) != 0)

System\ComponentModel\Container.cs (1)

232if (s?.Name != null && string.Equals(s.Name, name, StringComparison.OrdinalIgnoreCase) && s.Component != component)

System\ComponentModel\CultureInfoConverter.cs (3)

81if (string.IsNullOrEmpty(text) || string.Equals(text, defaultCultureString, StringComparison.Ordinal)) 91if (info != null && string.Equals(GetCultureName(info), text, StringComparison.Ordinal)) 116if (info != null && GetCultureName(info).StartsWith(text, StringComparison.CurrentCulture))

System\ComponentModel\EventDescriptorCollection.cs (2)

177if (string.Equals(_events[i]!.Name, name, StringComparison.OrdinalIgnoreCase)) 188if (string.Equals(_events[i]!.Name, name, StringComparison.Ordinal))

System\ComponentModel\PropertyDescriptorCollection.cs (1)

210if (string.Equals(_properties[i].Name, name, StringComparison.OrdinalIgnoreCase))

System\ComponentModel\ReferenceConverter.cs (1)

205return string.Compare(itemName1, itemName2, StringComparison.InvariantCulture);

System\ComponentModel\SyntaxCheck.cs (1)

43return value.StartsWith("\\\\", StringComparison.Ordinal);

System\Configuration\AppSettingsReader.cs (1)

87if (count > 0 && string.Compare(NullString, 0, val, count, len - 2 * count, StringComparison.Ordinal) != 0)

System\Configuration\BaseConfigurationRecord.cs (1)

3645return string.Equals(configKey, ReservedSectionProtectedConfiguration, StringComparison.Ordinal);

System\Configuration\ClientConfigurationSystem.cs (2)

71(_isAppConfigHttp && configKey.StartsWith(SystemNetGroupKey, StringComparison.Ordinal)); 79return _isAppConfigHttp && configKey.StartsWith(SystemNetGroupKey, StringComparison.Ordinal);

System\Configuration\ClientSettingsStore.cs (6)

274string.Equals(filename, ConfigurationManagerInternalFactory.Instance.MachineConfigPath, StringComparison.OrdinalIgnoreCase) || 275string.Equals(filename, ConfigurationManagerInternalFactory.Instance.ApplicationConfigUri, StringComparison.OrdinalIgnoreCase) || 276string.Equals(filename, ConfigurationManagerInternalFactory.Instance.ExeLocalConfigPath, StringComparison.OrdinalIgnoreCase) || 277string.Equals(filename, ConfigurationManagerInternalFactory.Instance.ExeRoamingConfigPath, StringComparison.OrdinalIgnoreCase); 314if (string.Equals(streamName, ConfigurationManagerInternalFactory.Instance.ExeLocalConfigPath, StringComparison.OrdinalIgnoreCase) || 315string.Equals(streamName, ConfigurationManagerInternalFactory.Instance.ExeRoamingConfigPath, StringComparison.OrdinalIgnoreCase))

System\Configuration\ConfigurationLockCollection.cs (1)

224parentListEnclosed.Contains("," + name + ",", StringComparison.Ordinal))

System\Configuration\StringUtil.cs (4)

10return string.Equals(s1 ?? string.Empty, s2 ?? string.Empty, StringComparison.Ordinal); 15return string.Equals(s1, s2, StringComparison.OrdinalIgnoreCase); 21return 0 == string.Compare(s1, 0, s2, 0, s2.Length, StringComparison.Ordinal); 27return 0 == string.Compare(s1, 0, s2, 0, s2.Length, StringComparison.OrdinalIgnoreCase);

System\Configuration\UrlPath.cs (2)

39if (string.Compare(dir, 0, subdir, 0, lDir, StringComparison.OrdinalIgnoreCase) != 0) 87if (string.Compare(path, 0, subpath, 0, lPath, StringComparison.OrdinalIgnoreCase) != 0)

src\libraries\Common\src\System\Console\ConsoleUtils.cs (1)

42enabled = envVar is not null && (envVar == "1" || envVar.Equals("true", StringComparison.OrdinalIgnoreCase));

System\TerminalFormatStrings.cs (3)

88IsRxvtTerm = !string.IsNullOrEmpty(db.Term) && db.Term.Contains("rxvt", StringComparison.OrdinalIgnoreCase); 196if (term.StartsWith("xterm", StringComparison.Ordinal)) // normalize all xterms to enable easier matching 200else if (term.StartsWith("screen", StringComparison.Ordinal)) // normalize all tmux configs

src\libraries\Common\src\System\Data\Common\AdapterUtil.cs (2)

164if (!quotedString.StartsWith(quotePrefix!, StringComparison.Ordinal)) 174if (!quotedString.EndsWith(quoteSuffix!, StringComparison.Ordinal))

src\libraries\Common\src\System\Data\Common\DbConnectionOptions.Common.cs (3)

522if (msg2.StartsWith(WrongFormatMessagePrefix, StringComparison.Ordinal)) 524if (msg1.StartsWith(KeywordNotSupportedMessagePrefix, StringComparison.Ordinal) || msg1.StartsWith(WrongFormatMessagePrefix, StringComparison.Ordinal))

System\Data\Common\DBCommandBuilder.cs (4)

70if (columnName.StartsWith(_originalPrefix, StringComparison.OrdinalIgnoreCase)) 77if (columnName.StartsWith(_isNullPrefix, StringComparison.OrdinalIgnoreCase)) 736if (!string.IsNullOrEmpty(quotePrefix) && baseTableName.Contains(quotePrefix, StringComparison.Ordinal)) 740if (!string.IsNullOrEmpty(quoteSuffix) && baseTableName.Contains(quoteSuffix, StringComparison.Ordinal))

System\Data\Common\DbConnectionOptions.cs (1)

91(('{' == keyValue[0]) || (0 <= keyValue.IndexOf(';')) || string.Equals(DbConnectionStringKeywords.Driver, keyName, StringComparison.OrdinalIgnoreCase)) &&

System\Data\DataRelation.cs (1)

556if (!string.Equals(parentNs, rel.ParentTable.Namespace, StringComparison.Ordinal))

System\Data\DataSet.cs (17)

System\Data\DataTable.cs (6)

3720if (length >= 5 && string.Compare(current, length - 4, " ASC", 0, 4, StringComparison.OrdinalIgnoreCase) == 0) 3724else if (length >= 6 && string.Compare(current, length - 5, " DESC", 0, 5, StringComparison.OrdinalIgnoreCase) == 0) 5830if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal)) 5899if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal)) 6100if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal)) 6194if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal))

System\Data\DataView.cs (3)

1755/// <see cref="RowFilter"/> and <see cref="Sort"/> may differ by <see cref="StringComparison.OrdinalIgnoreCase"/>. 1762!string.Equals(RowFilter, view.RowFilter, StringComparison.OrdinalIgnoreCase) || // case insensitive 1763!string.Equals(Sort, view.Sort, StringComparison.OrdinalIgnoreCase) || // case insensitive

System\Data\DefaultValueTypeConverter.cs (2)

46if (string.Equals(strValue, NullString, StringComparison.OrdinalIgnoreCase)) 50else if (string.Equals(strValue, DbNullString, StringComparison.OrdinalIgnoreCase))

System\Data\Filter\FunctionNode.cs (2)

54if (string.Equals(s_funcs[i]._name, name, StringComparison.OrdinalIgnoreCase)) 374return ((string)argumentValues[1]).IndexOf((string)argumentValues[0], StringComparison.Ordinal);

System\Data\SimpleType.cs (2)

330if (!string.Equals(BaseType, otherSimpleType.BaseType, StringComparison.Ordinal)) 347return string.Equals(rootType.BaseType, "string", StringComparison.OrdinalIgnoreCase);

System\Data\XDRSchema.cs (3)

202if (!string.Equals(occurs, "1", StringComparison.Ordinal) && (typeNode == null)) 227public int CompareTo(object? obj) { return string.Compare(name, (string?)obj, StringComparison.Ordinal); } 508int bZeroOrMore = string.Compare(occurs, Keywords.STAR, StringComparison.Ordinal);

System\Data\XmlDataLoader.cs (3)

247if (ownerNode.NamespaceURI.StartsWith("x-schema:#", StringComparison.Ordinal)) 255if (_fIsXdr && node.NamespaceURI.StartsWith("x-schema:#", StringComparison.Ordinal)) 941else if (_dataReader.LocalName.StartsWith("hidden", StringComparison.Ordinal))

System\Data\XMLDiffLoader.cs (2)

285if (string.Equals(dt.TableName, tableName, StringComparison.Ordinal) 286&& string.Equals(dt.Namespace, ns, StringComparison.Ordinal))

System\Data\xmlsaver.cs (16)

System\Data\XMLSchema.cs (8)

System\Data\XmlToDatasetMap.cs (5)

33(string.Equals(LocalName, id.LocalName, StringComparison.OrdinalIgnoreCase)) && 34(string.Equals(NamespaceURI, id.NamespaceURI, StringComparison.OrdinalIgnoreCase)) 219if (col.ColumnName.StartsWith("xml", StringComparison.OrdinalIgnoreCase)) 253if (col.ColumnName.StartsWith("xml", StringComparison.OrdinalIgnoreCase)) 506Debug.Assert(col.ColumnName.StartsWith("xml", StringComparison.OrdinalIgnoreCase), "column name should start with xml");

Common\System\Data\Common\DbConnectionOptions.cs (3)

152(('{' == keyValue[0]) || (0 <= keyValue.IndexOf(';')) || (string.Equals(DbConnectionStringKeywords.Driver, keyName, StringComparison.OrdinalIgnoreCase))) && 266if ((null != value) && value.StartsWith(DataDirectory, StringComparison.OrdinalIgnoreCase)) 313if (!ADP.GetFullPath(fullPath).StartsWith(rootFolderPath, StringComparison.Ordinal))

src\libraries\Common\src\System\Data\Common\AdapterUtil.cs (2)

164if (!quotedString.StartsWith(quotePrefix!, StringComparison.Ordinal)) 174if (!quotedString.EndsWith(quoteSuffix!, StringComparison.Ordinal))

src\libraries\Common\src\System\Data\Common\DbConnectionOptions.Common.cs (3)

522if (msg2.StartsWith(WrongFormatMessagePrefix, StringComparison.Ordinal)) 524if (msg1.StartsWith(KeywordNotSupportedMessagePrefix, StringComparison.Ordinal) || msg1.StartsWith(WrongFormatMessagePrefix, StringComparison.Ordinal))

src\libraries\Common\src\System\Data\ProviderBase\DbMetaDataFactory.cs (2)

519if (0 > string.Compare(_normalizedServerVersion, (string)version, StringComparison.OrdinalIgnoreCase)) 538if (0 < string.Compare(_normalizedServerVersion, (string)version, StringComparison.OrdinalIgnoreCase))

System\Data\Odbc\OdbcDataReader.cs (4)

2889if (useQuotes && (name.IndexOf(quotePrefix!, currentPos, quotePrefix!.Length, StringComparison.Ordinal) == currentPos)) 2898currentPos = name.IndexOf(quoteSuffix, currentPos, StringComparison.Ordinal); 2910if ((currentPos < name.Length) && (name.IndexOf(quoteSuffix, currentPos, quoteSuffix.Length, StringComparison.Ordinal) == currentPos)) 2927currentPos = name.IndexOf(Separator, currentPos, StringComparison.Ordinal);

System\Data\Odbc\OdbcParameterCollectionHelper.cs (1)

324if (lastParameter.ParameterName.StartsWith(ADP.Parameter, StringComparison.Ordinal)

System\Data\Odbc\OdbcUtils.cs (2)

522if (string.Equals(tokenString, nextToken, StringComparison.OrdinalIgnoreCase)) 543if (0 == string.Compare(_sqlstatement, tempidx, tokenString, 0, tokenString.Length, StringComparison.OrdinalIgnoreCase))

System\Diagnostics\ActivitySource.cs (1)

56tagList.Sort((left, right) => string.Compare(left.Key, right.Key, StringComparison.Ordinal));

System\Diagnostics\DsesActivitySourceListener.cs (2)

236=> string.Equals(x.activitySourceName, y.activitySourceName, StringComparison.OrdinalIgnoreCase) 237&& string.Equals(x.activityName, y.activityName, StringComparison.OrdinalIgnoreCase);

System\Diagnostics\DsesFilterAndTransform.cs (7)

98filterAndPayloadSpec.AsSpan(startIdx, endIdx - startIdx).StartsWith(c_ActivitySourcePrefix.AsSpan(), StringComparison.Ordinal); 241if (suffixPart.Equals("Propagate".AsSpan(), StringComparison.OrdinalIgnoreCase)) 245else if (suffixPart.Equals("Record".AsSpan(), StringComparison.OrdinalIgnoreCase)) 249else if (suffixPart.StartsWith(c_ParentRatioSamplerPrefix.AsSpan(), StringComparison.OrdinalIgnoreCase)) 266else if (suffixPart.StartsWith(c_ParentRateLimitingSamplerPrefix.AsSpan(), StringComparison.OrdinalIgnoreCase)) 305if (eventName.Equals("Start".AsSpan(), StringComparison.OrdinalIgnoreCase)) 309else if (eventName.Equals("Stop".AsSpan(), StringComparison.OrdinalIgnoreCase))

System\Diagnostics\LocalAppContextSwitches.cs (1)

21defaultActivityIdFormatIsHierarchial = switchValue.Equals("true", StringComparison.OrdinalIgnoreCase) || switchValue.Equals("1");

System\Diagnostics\Metrics\AggregationManager.cs (4)

96Include(i => i.Meter.Name.Equals(meterName, StringComparison.OrdinalIgnoreCase)); 106Include(i => i.Meter.Name.StartsWith(meterNamePrefix, StringComparison.OrdinalIgnoreCase)); 111Include(i => i.Meter.Name.Equals(meterName, StringComparison.OrdinalIgnoreCase) 112&& i.Name.Equals(instrumentName, StringComparison.OrdinalIgnoreCase));

System\Diagnostics\Metrics\Instrument.cs (1)

76tagList.Sort((left, right) => string.Compare(left.Key, right.Key, StringComparison.Ordinal));

System\Diagnostics\Metrics\Meter.cs (1)

82tagList.Sort((left, right) => string.Compare(left.Key, right.Key, StringComparison.Ordinal));

System\Diagnostics\FileVersionInfo.Unix.cs (2)

84if (!assemblyName.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) && 85!assemblyName.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))

src\libraries\Common\src\Interop\Linux\cgroups\Interop.cgroups.cs (2)

291if ((commonPathPrefixLength == 1) || !cgroupPathRelativeToMount.StartsWith(hierarchyRoot, StringComparison.Ordinal)) 337int endOfOptionalFields = line.IndexOf(Separator, StringComparison.Ordinal);

System\Diagnostics\Process.Linux.cs (2)

38if ((processName == "" || string.Equals(processName, actualProcessName, StringComparison.OrdinalIgnoreCase)) && 350if (argString.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))

System\Diagnostics\Process.Unix.cs (1)

412!string.Equals(verb, "open", StringComparison.OrdinalIgnoreCase))

System\Drawing\FontConverter.cs (3)

374if (name.Equals(font.Name, StringComparison.OrdinalIgnoreCase)) 451if (fontName.Equals(name, StringComparison.InvariantCultureIgnoreCase)) 457if (fontName.StartsWith(name, StringComparison.InvariantCultureIgnoreCase))

System\Drawing\ImageFormatConverter.cs (12)

System\Drawing\ToolboxBitmapAttribute.cs (3)

154if (ext is not null && string.Equals(ext, ".ico", StringComparison.OrdinalIgnoreCase)) 250if (string.Equals(Path.GetExtension(imageName), ".ico", StringComparison.CurrentCultureIgnoreCase)) 254else if (string.Equals(Path.GetExtension(imageName), ".bmp", StringComparison.CurrentCultureIgnoreCase))

Helpers.cs (2)

35if (name.StartsWith(PrintToPdfPrinterName, StringComparison.Ordinal)) 55if (name.StartsWith(PrintToPdfPrinterName, StringComparison.Ordinal))

System\Drawing\FontTests.cs (1)

885if (font1.Name.Equals(font2.Name, StringComparison.OrdinalIgnoreCase))

src\libraries\Common\src\System\Drawing\ColorConverterCommon.cs (2)

99else if (text.StartsWith("0x", StringComparison.OrdinalIgnoreCase) || text.StartsWith("&h", StringComparison.OrdinalIgnoreCase))

System\Drawing\ColorTranslator.cs (1)

253if (c.IsEmpty && string.Equals(htmlColor, "LightGrey", StringComparison.OrdinalIgnoreCase))

src\libraries\Common\src\System\IO\PathInternal.CaseSensitivity.cs (3)

12internal static StringComparison StringComparison 17StringComparison.Ordinal : 18StringComparison.OrdinalIgnoreCase;

src\libraries\Common\src\System\IO\PathInternal.cs (1)

82internal static bool AreRootsEqual(string? first, string? second, StringComparison comparisonType)

src\libraries\Common\src\System\IO\PathInternal.CaseSensitivity.cs (3)

12internal static StringComparison StringComparison 17StringComparison.Ordinal : 18StringComparison.OrdinalIgnoreCase;

src\libraries\Common\src\System\IO\PathInternal.CaseSensitivity.cs (3)

12internal static StringComparison StringComparison 17StringComparison.Ordinal : 18StringComparison.OrdinalIgnoreCase;

src\libraries\Common\src\System\IO\PathInternal.CaseSensitivity.cs (3)

12internal static StringComparison StringComparison 17StringComparison.Ordinal : 18StringComparison.OrdinalIgnoreCase;

src\libraries\Common\src\System\IO\PathInternal.cs (1)

82internal static bool AreRootsEqual(string? first, string? second, StringComparison comparisonType)

System\IO\FileSystemWatcher.Linux.cs (1)

624if (previousEventName.Equals(child.Name, StringComparison.Ordinal))

System\IO\IsolatedStorage\IsolatedStorageFile.NonMobile.cs (3)

67(Helper.IsApplication(Scope) && string.Equals(directoryName, s_appFiles, StringComparison.Ordinal)) 68|| (Helper.IsAssembly(Scope) && string.Equals(directoryName, s_assemFiles, StringComparison.Ordinal)) 69|| (Helper.IsDomain(Scope) && string.Equals(directoryName, s_files, StringComparison.Ordinal));

System\IO\Packaging\ContentType.cs (2)

202result = (string.Equals(_type, contentType.TypeComponent, StringComparison.OrdinalIgnoreCase) && 203string.Equals(_subType, contentType.SubTypeComponent, StringComparison.OrdinalIgnoreCase));

System\IO\Packaging\Package.cs (4)

355if (Uri.Compare(owningPartUri, PackUriHelper.PackageRootUri, UriComponents.SerializationInfoString, UriFormat.UriEscaped, StringComparison.Ordinal) == 0) 444&& normalizedPartName.StartsWith(precedingPartName, StringComparison.Ordinal) 998&& normalizedPartName.StartsWith(precedingPartName, StringComparison.Ordinal) 1002&& followingPartName.StartsWith(normalizedPartName, StringComparison.Ordinal)

System\IO\Packaging\PackageRelationshipSelector.cs (1)

37if (Uri.Compare(sourceUri, PackUriHelper.PackageRootUri, UriComponents.SerializationInfoString, UriFormat.UriEscaped, StringComparison.Ordinal) != 0)

System\IO\Packaging\PackagingUtilities.cs (4)

45if (string.Equals(encoding, WebNameUTF8, StringComparison.OrdinalIgnoreCase) || 46string.Equals(encoding, WebNameUnicode, StringComparison.OrdinalIgnoreCase)) 97if (!string.Equals(reader.Name, XmlNamespace, StringComparison.Ordinal) && 98!string.Equals(reader.Prefix, XmlNamespace, StringComparison.Ordinal))

System\IO\Packaging\PackUriHelper.cs (5)

191if (Uri.Compare(partUri, PackageRootUri, UriComponents.SerializationInfoString, UriFormat.UriEscaped, StringComparison.Ordinal) == 0) 419if (!string.Equals(partUri.OriginalString, wellFormedPartName, StringComparison.OrdinalIgnoreCase)) 516StringComparison.Ordinal); 762if (!NormalizedPartUriString.EndsWith(RelationshipPartUpperCaseExtension, StringComparison.Ordinal)) 801if ((segments[segments.Length - 1]).EndsWith(RelsrelsUpperCaseExtension, StringComparison.Ordinal))

System\IO\Packaging\XmlCompatibilityReader.cs (2)

622if (string.Equals(XmlnsDeclaration, Reader.LocalName, StringComparison.Ordinal)) 627else if (string.Equals(XmlnsDeclaration, Reader.Prefix, StringComparison.Ordinal))

System\IO\Packaging\ZipPackage.cs (5)

508if (zipItemName.StartsWith(ContentTypeHelper.ContentTypeFileName, StringComparison.OrdinalIgnoreCase)) 517if (zipItemName.StartsWith(ForwardSlashString, StringComparison.Ordinal)) 523if (zipItemName.EndsWith(ForwardSlashString, StringComparison.Ordinal)) 742return extensionA.Equals(extensionB, StringComparison.OrdinalIgnoreCase); 1052if (zipFileInfo.FullName.StartsWith(ContentTypesFileUpperInvariant, StringComparison.OrdinalIgnoreCase))

System\IO\Packaging\ZipPackagePartPiece.cs (3)

57int resultPosition = path.LastIndexOf(".piece", StringComparison.OrdinalIgnoreCase); 81else if (path.Substring(0, searchPosition).EndsWith(PartPieceLastExtension, StringComparison.OrdinalIgnoreCase)) 196int result = string.Compare(PrefixName, other.PrefixName, StringComparison.OrdinalIgnoreCase);

System\IO\Pipes\PipeStream.Unix.cs (1)

193if (string.Equals(pipeName, AnonymousPipeName, StringComparison.OrdinalIgnoreCase))

System\IO\Ports\SerialPort.Unix.cs (13)

System\Dynamic\ExpandoClass.cs (3)

68if (string.Equals(klass._keys[klass._keys.Length - 1], newKey, StringComparison.Ordinal)) 128StringComparison.Ordinal)) 158StringComparison.OrdinalIgnoreCase))

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

110if (!addMethod.Name.Equals("Add", StringComparison.OrdinalIgnoreCase))

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

280if (pi.Name.Equals(propertyName, StringComparison.OrdinalIgnoreCase) && IsCompatible(pi, arguments))

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

1309if (mi.Name.Equals(methodName, StringComparison.OrdinalIgnoreCase))

src\libraries\Common\src\System\Net\CredentialCacheKey.cs (3)

36if (!string.Equals(authenticationType, AuthenticationType, StringComparison.OrdinalIgnoreCase)) 73return string.Compare(uri.AbsolutePath, 0, uriPrefix.AbsolutePath, 0, UriPrefixLength, StringComparison.OrdinalIgnoreCase) == 0; 88string.Equals(AuthenticationType, other.AuthenticationType, StringComparison.OrdinalIgnoreCase) &&

src\libraries\Common\src\System\Net\HttpKnownHeaderNames.TryGetHeaderName.cs (2)

30if (value.Equals(Gzip.AsSpan(), StringComparison.OrdinalIgnoreCase)) 35if (value.Equals(Deflate.AsSpan(), StringComparison.OrdinalIgnoreCase))

System\Net\Http\FormUrlEncodedContent.cs (1)

70int indexOfEscapedSpace = escapedChars.IndexOf("%20", StringComparison.Ordinal);

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

74return (string.Equals(_scheme, other._scheme, StringComparison.OrdinalIgnoreCase)); 79return string.Equals(_scheme, other._scheme, StringComparison.OrdinalIgnoreCase) && 80string.Equals(_parameter, other._parameter, StringComparison.Ordinal);

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

168return string.Equals(_dispositionType, other._dispositionType, StringComparison.OrdinalIgnoreCase) && 463!processedInputSpan[parts[2]].Equals("b", StringComparison.OrdinalIgnoreCase))

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

99string.Equals(_unit, other._unit, StringComparison.OrdinalIgnoreCase);

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

60string.Equals(Tag, other.Tag, StringComparison.Ordinal);

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

46return string.Equals(headerName, other._descriptor as string, StringComparison.OrdinalIgnoreCase);

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

87if (value is string stringValue && stringValue.Equals("chunked", StringComparison.OrdinalIgnoreCase))

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

132string.Equals(_mediaType, other._mediaType, StringComparison.OrdinalIgnoreCase) &&

System\Net\Http\Headers\NameValueHeaderValue.cs (4)

90if (!string.Equals(_name, other._name, StringComparison.OrdinalIgnoreCase)) 107return string.Equals(_value, other._value, StringComparison.Ordinal); 111return string.Equals(_value, other._value, StringComparison.OrdinalIgnoreCase); 315if (string.Equals(value.Name, name, StringComparison.OrdinalIgnoreCase))

System\Net\Http\Headers\ProductHeaderValue.cs (2)

69return string.Equals(_name, other._name, StringComparison.OrdinalIgnoreCase) && 70string.Equals(_version, other._version, StringComparison.OrdinalIgnoreCase);

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

66return string.Equals(_comment, other._comment, StringComparison.Ordinal);

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

93return string.Equals(_unit, other._unit, StringComparison.OrdinalIgnoreCase) &&

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

55string.Equals(_value, other._value, StringComparison.OrdinalIgnoreCase) &&

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

129return string.Equals(_value, other._value, StringComparison.OrdinalIgnoreCase) &&

System\Net\Http\Headers\ViaHeaderValue.cs (4)

106string.Equals(_protocolVersion, other._protocolVersion, StringComparison.OrdinalIgnoreCase) && 107string.Equals(_receivedBy, other._receivedBy, StringComparison.OrdinalIgnoreCase) && 108string.Equals(_protocolName, other._protocolName, StringComparison.OrdinalIgnoreCase) && 109string.Equals(_comment, other._comment, StringComparison.Ordinal);

System\Net\Http\Headers\WarningHeaderValue.cs (2)

103string.Equals(_agent, other._agent, StringComparison.OrdinalIgnoreCase) && 104string.Equals(_text, other._text, StringComparison.Ordinal) &&

System\Net\Http\HttpClient.cs (1)

575!string.Equals(request.Method.Method, "HEAD", StringComparison.OrdinalIgnoreCase);

System\Net\Http\HttpMethod.cs (2)

53string.Equals(_method, other._method, StringComparison.OrdinalIgnoreCase); 114method.Equals(match._method, StringComparison.OrdinalIgnoreCase))

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.Digest.cs (16)

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.NtAuth.cs (2)

44(envVar == "1" || envVar.Equals("true", StringComparison.OrdinalIgnoreCase)) ? 1 : 0; 67if (v.Equals("Session-Based-Authentication", StringComparison.OrdinalIgnoreCase))

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

43if (string.Equals(existingEncoding.Value, encoding, StringComparison.OrdinalIgnoreCase)) 81if (GZipEnabled && string.Equals(last, Gzip, StringComparison.OrdinalIgnoreCase)) 85else if (DeflateEnabled && string.Equals(last, Deflate, StringComparison.OrdinalIgnoreCase)) 89else if (BrotliEnabled && string.Equals(last, Brotli, StringComparison.OrdinalIgnoreCase))

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

1460if (string.Equals(value, "trailers", StringComparison.OrdinalIgnoreCase))

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

754if (string.Equals(value, "trailers", StringComparison.OrdinalIgnoreCase))

System\Net\Http\SocketsHttpHandler\HttpConnection.cs (2)

1341if (string.Equals(nameValue.Name, "timeout", StringComparison.OrdinalIgnoreCase)) 1361else if (string.Equals(nameValue.Name, "max", StringComparison.OrdinalIgnoreCase))

System\Net\Http\SocketsHttpHandler\HttpEnvironmentProxy.cs (8)

System\Net\Http\SocketsHttpHandler\HttpUtilities.cs (9)

System\Net\Http\SocketsHttpHandler\SocksHelper.cs (3)

40if (string.Equals(proxyUri.Scheme, "socks5", StringComparison.OrdinalIgnoreCase)) 44else if (string.Equals(proxyUri.Scheme, "socks4a", StringComparison.OrdinalIgnoreCase)) 48else if (string.Equals(proxyUri.Scheme, "socks4", StringComparison.OrdinalIgnoreCase))

src\libraries\Common\src\System\Net\CookieComparer.cs (3)

10if (!string.Equals(left.Name, right.Name, StringComparison.OrdinalIgnoreCase)) 22return string.Equals(left.Path, right.Path, StringComparison.Ordinal); 26=> StripLeadingDot(left).Equals(StripLeadingDot(right), StringComparison.OrdinalIgnoreCase);

src\libraries\Common\src\System\Net\CookieParser.cs (1)

454return string.Equals(_name, value, StringComparison.OrdinalIgnoreCase);

System\Net\HttpListener.cs (2)

116if (string.Compare(uriPrefix, 0, "http://", 0, 7, StringComparison.OrdinalIgnoreCase) == 0) 120else if (string.Compare(uriPrefix, 0, "https://", 0, 8, StringComparison.OrdinalIgnoreCase) == 0)

System\Net\HttpListenerRequest.cs (4)

130if (string.Equals(connection, HttpKnownHeaderNames.Upgrade, StringComparison.OrdinalIgnoreCase)) 144if (string.Equals(upgrade, HttpWebSocket.WebSocketUpgradeToken, StringComparison.OrdinalIgnoreCase)) 181header.IndexOf("close", StringComparison.OrdinalIgnoreCase) < 0 || 182header.Contains("keep-alive", StringComparison.OrdinalIgnoreCase);

System\Net\HttpListenerRequestUriBuilder.cs (2)

379if (uriString.StartsWith("http://", StringComparison.OrdinalIgnoreCase)) 383else if (uriString.StartsWith("https://", StringComparison.OrdinalIgnoreCase))

System\Net\Managed\HttpEndPointListener.cs (3)

201if (path.StartsWith(ppath, StringComparison.Ordinal) || pathSlash.StartsWith(ppath, StringComparison.Ordinal)) 248if (path.StartsWith(ppath, StringComparison.Ordinal))

System\Net\Managed\HttpListenerContext.Managed.cs (1)

56string.Compare(header, 0, AuthenticationTypes.Basic, 0, 5, StringComparison.OrdinalIgnoreCase) == 0;

System\Net\Managed\HttpListenerRequest.Managed.cs (7)

96if (version.Length != 8 || !version.StartsWith("HTTP/", StringComparison.Ordinal)) 182_isChunked = (t_encoding != null && string.Equals(t_encoding, "chunked", StringComparison.OrdinalIgnoreCase)); 193if (string.Equals(_method, "POST", StringComparison.OrdinalIgnoreCase) || 194string.Equals(_method, "PUT", StringComparison.OrdinalIgnoreCase)) 201if (string.Equals(Headers[HttpKnownHeaderNames.Expect], "100-continue", StringComparison.OrdinalIgnoreCase)) 220if (name.Equals("content-length", StringComparison.OrdinalIgnoreCase)) 240else if (name.Equals("transfer-encoding", StringComparison.OrdinalIgnoreCase))

System\Net\Managed\HttpListenerResponse.Managed.cs (3)

288!string.Equals(name, HttpKnownHeaderNames.Location, StringComparison.OrdinalIgnoreCase); 310if (key.Equals(HttpKnownHeaderNames.SetCookie, StringComparison.OrdinalIgnoreCase) || 311key.Equals(HttpKnownHeaderNames.SetCookie2, StringComparison.OrdinalIgnoreCase))

System\Net\Managed\ListenerPrefix.cs (1)

101if (uri.StartsWith("https://", StringComparison.Ordinal))

System\Net\ServiceNameStore.cs (3)

113if (inputServiceName.Equals(normalizedServiceName, StringComparison.OrdinalIgnoreCase)) 203if (serviceName.Equals(newServiceName, StringComparison.OrdinalIgnoreCase)) 227int i = uriPrefix.IndexOf("://", StringComparison.Ordinal) + 3;

System\Net\WebSockets\HttpWebSocket.cs (2)

67if (string.Equals(acceptProtocol, currentRequestProtocol, StringComparison.OrdinalIgnoreCase)) 126if (!string.Equals(secWebSocketVersion, SupportedVersion, StringComparison.OrdinalIgnoreCase))

System\Net\Mail\MailAddress.cs (1)

277return ToString().Equals(value.ToString(), StringComparison.InvariantCultureIgnoreCase);

System\Net\Mail\MailPriority.cs (1)

547if (string.Equals(Headers.GetKey(i), headerName, StringComparison.InvariantCultureIgnoreCase))

System\Net\Mail\SmtpConnection.Auth.cs (7)

49SizeOfAuthExtension, StringComparison.OrdinalIgnoreCase) == 0) 56if (string.Equals(authType, AuthLogin, StringComparison.OrdinalIgnoreCase)) 60else if (string.Equals(authType, AuthNtlm, StringComparison.OrdinalIgnoreCase)) 64else if (string.Equals(authType, AuthGssapi, StringComparison.OrdinalIgnoreCase)) 70else if (string.Compare(extension, 0, "dsn ", 0, 3, StringComparison.OrdinalIgnoreCase) == 0) 74else if (string.Compare(extension, 0, "STARTTLS", 0, 8, StringComparison.OrdinalIgnoreCase) == 0) 78else if (string.Compare(extension, 0, "SMTPUTF8", 0, 8, StringComparison.OrdinalIgnoreCase) == 0)

System\Net\Mime\ContentDisposition.cs (1)

248string.Equals(ToString(), rparam.ToString(), StringComparison.OrdinalIgnoreCase);

System\Net\Mime\ContentType.cs (1)

213rparam == null ? false : string.Equals(ToString(), rparam.ToString(), StringComparison.OrdinalIgnoreCase);

System\Net\Mime\MimePart.cs (4)

57if (value.Equals("base64", StringComparison.OrdinalIgnoreCase)) 61else if (value.Equals("quoted-printable", StringComparison.OrdinalIgnoreCase)) 65else if (value.Equals("7bit", StringComparison.OrdinalIgnoreCase)) 69else if (value.Equals("8bit", StringComparison.OrdinalIgnoreCase))

src\libraries\Common\src\System\Net\SocketProtocolSupportPal.cs (1)

30return envVar == "1" || envVar.Equals("true", StringComparison.OrdinalIgnoreCase);

src\libraries\Common\src\System\IO\RowConfigReader.cs (3)

18private readonly StringComparison _comparisonKind; 28_comparisonKind = StringComparison.Ordinal; 37public RowConfigReader(string buffer, StringComparison comparisonKind)

System\Net\NetworkInformation\StringParsingHelpers.Addresses.cs (8)

System\Net\NetworkInformation\StringParsingHelpers.Connections.cs (2)

16int indexOfTcp = sockstatFile.IndexOf(protocolName, StringComparison.Ordinal); 17int endOfTcpLine = sockstatFile.IndexOf(Environment.NewLine, indexOfTcp + 1, StringComparison.Ordinal);

System\Net\NetworkInformation\StringParsingHelpers.Misc.cs (3)

90int firstIpHeader = snmp4FileContents.IndexOf("Ip:", StringComparison.Ordinal); 91int secondIpHeader = snmp4FileContents.IndexOf("Ip:", firstIpHeader + 1, StringComparison.Ordinal); 92int endOfSecondLine = snmp4FileContents.IndexOf(Environment.NewLine, secondIpHeader, StringComparison.Ordinal);

System\Net\NetworkInformation\StringParsingHelpers.Statistics.cs (15)

src\libraries\Common\src\System\Net\NetworkInformation\UnixCommandLinePing.cs (3)

51if (linkInfo?.Name.EndsWith("busybox", StringComparison.Ordinal) == true) 211int timeIndex = pingOutput.IndexOf("time=", StringComparison.Ordinal); 213int msIndex = pingOutput.IndexOf("ms", afterTime, StringComparison.Ordinal);

src\libraries\Common\src\System\Net\SocketProtocolSupportPal.cs (1)

30return envVar == "1" || envVar.Equals("true", StringComparison.OrdinalIgnoreCase);

System\Net\NetworkInformation\Ping.PingUtility.cs (2)

131if (!stdout.Contains("Time to live exceeded", StringComparison.Ordinal)) 139int addressStart = stdout.IndexOf("From ", StringComparison.Ordinal) + 5;

src\libraries\Common\src\System\Net\CookieComparer.cs (3)

10if (!string.Equals(left.Name, right.Name, StringComparison.OrdinalIgnoreCase)) 22return string.Equals(left.Path, right.Path, StringComparison.Ordinal); 26=> StripLeadingDot(left).Equals(StripLeadingDot(right), StringComparison.OrdinalIgnoreCase);

src\libraries\Common\src\System\Net\CookieParser.cs (1)

454return string.Equals(_name, value, StringComparison.OrdinalIgnoreCase);

src\libraries\Common\src\System\Net\CredentialCacheKey.cs (3)

36if (!string.Equals(authenticationType, AuthenticationType, StringComparison.OrdinalIgnoreCase)) 73return string.Compare(uri.AbsolutePath, 0, uriPrefix.AbsolutePath, 0, UriPrefixLength, StringComparison.OrdinalIgnoreCase) == 0; 88string.Equals(AuthenticationType, other.AuthenticationType, StringComparison.OrdinalIgnoreCase) &&

System\Net\Cookie.cs (5)

80Debug.Assert(MaxSupportedVersion.ToString(NumberFormatInfo.InvariantInfo).Equals(MaxSupportedVersionString, StringComparison.Ordinal)); 333if (!host.EndsWith(domain, StringComparison.Ordinal)) 626&& string.Equals(Name, other.Name, StringComparison.OrdinalIgnoreCase) 627&& string.Equals(Value, other.Value, StringComparison.Ordinal) 628&& string.Equals(Path, other.Path, StringComparison.Ordinal)

System\Net\CookieCollection.cs (1)

52if (string.Equals(c!.Name, name, StringComparison.OrdinalIgnoreCase))

System\Net\CookieContainer.cs (3)

583if ((string.Equals(headerName, s_headerInfo[i].Name, StringComparison.OrdinalIgnoreCase))) 756if (!requestPath.StartsWith(cookiePath, StringComparison.Ordinal)) 807if (cookie.DomainImplicit && !string.Equals(host, cookie.Domain, StringComparison.OrdinalIgnoreCase))

System\Net\CredentialCache.cs (8)

src\libraries\Common\src\System\AppContextSwitchHelper.cs (2)

22if (str == "1" || string.Equals(str, bool.TrueString, StringComparison.OrdinalIgnoreCase)) 26if (str == "0" || string.Equals(str, bool.FalseString, StringComparison.OrdinalIgnoreCase))

System\Net\FileWebRequest.cs (2)

121if (string.Equals(_method, "GET", StringComparison.OrdinalIgnoreCase) || 122string.Equals(_method, "HEAD", StringComparison.OrdinalIgnoreCase))

System\Net\FtpControlStream.cs (6)

439if (entry.Command.StartsWith("SIZE ", StringComparison.Ordinal)) 443else if (entry.Command.StartsWith("MDTM ", StringComparison.Ordinal)) 968int start = str.IndexOf("for ", StringComparison.Ordinal); 1020int pos2 = str.IndexOf(" bytes).", StringComparison.Ordinal); 1150if (parameter is not null && parameter.Contains("\r\n", StringComparison.Ordinal)) 1220while ((index = responseString.IndexOf("\r\n", validThrough, StringComparison.Ordinal)) != -1) // gets the end line.

System\Net\FtpWebRequest.cs (1)

492if (uri.OriginalString.Contains("\r\n", StringComparison.Ordinal))

System\Net\HttpWebRequest.cs (9)

System\Net\HttpWebResponse.cs (2)

278if (srchString.AsSpan().Trim().StartsWith("text/", StringComparison.Ordinal)) 289while ((i = srchString.IndexOf("charset", i, StringComparison.Ordinal)) >= 0)

System\Net\WebRequest.cs (2)

120StringComparison.OrdinalIgnoreCase) == 0) 289if (string.Equals(Current.Prefix, prefix, StringComparison.OrdinalIgnoreCase))

src\libraries\Common\src\System\Net\Http\X509ResourceClient.cs (1)

308return string.Equals(scheme, "http", StringComparison.OrdinalIgnoreCase);

System\Net\NegotiateAuthenticationPal.Unix.cs (4)

30(OperatingSystem.IsLinux() && RuntimeInformation.RuntimeIdentifier.StartsWith("linux-bionic-", StringComparison.OrdinalIgnoreCase)); 462if (string.Equals(package, NegotiationInfoClass.Negotiate, StringComparison.OrdinalIgnoreCase)) 466else if (string.Equals(package, NegotiationInfoClass.NTLM, StringComparison.OrdinalIgnoreCase)) 470else if (string.Equals(package, NegotiationInfoClass.Kerberos, StringComparison.OrdinalIgnoreCase))

System\Net\Security\SslStream.Protocol.cs (1)

44(envVar == "1" || envVar.Equals("true", StringComparison.OrdinalIgnoreCase)) ? 1 : 0;

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

60if (string.Equals(serviceName, searchName, StringComparison.OrdinalIgnoreCase)) 256if (string.Equals(inputServiceName, normalizedServiceName, StringComparison.OrdinalIgnoreCase))

src\libraries\Common\src\System\Net\SocketProtocolSupportPal.cs (1)

30return envVar == "1" || envVar.Equals("true", StringComparison.OrdinalIgnoreCase);

System\Net\WebClient.cs (4)

487else if (contentType.StartsWith("multipart/", StringComparison.OrdinalIgnoreCase)) 497if (string.Equals(_method, "POST", StringComparison.Ordinal)) 595if (contentType != null && !string.Equals(contentType, UploadValuesContentType, StringComparison.OrdinalIgnoreCase)) 1171return string.Equals(uri.Scheme, Uri.UriSchemeFtp, StringComparison.Ordinal) ?

System\Net\HeaderInfoTable.cs (1)

77return lastElement.Slice(0, equalsPos).Trim().Equals("Expires", StringComparison.OrdinalIgnoreCase);

System\Net\WebProxy.cs (1)

115if (!address.Contains("://", StringComparison.Ordinal))

System\Net\WebProxy.NonWasm.cs (1)

44string.Compare(local, 0, hostString, dot, local.Length, StringComparison.OrdinalIgnoreCase) == 0;

System\Net\WebSockets\ClientWebSocketOptions.cs (1)

167if (string.Equals(item, subProtocol, StringComparison.OrdinalIgnoreCase))

System\Net\WebSockets\WebSocketHandle.Managed.cs (2)

160if (requestedProtocol.Equals(subprotocolArray[0], StringComparison.OrdinalIgnoreCase)) 519if (string.Equals(value, expectedValue, StringComparison.OrdinalIgnoreCase))

src\libraries\Common\src\System\IO\PathInternal.CaseSensitivity.cs (3)

12internal static StringComparison StringComparison 17StringComparison.Ordinal : 18StringComparison.OrdinalIgnoreCase;

src\libraries\Common\src\System\IO\PathInternal.cs (1)

82internal static bool AreRootsEqual(string? first, string? second, StringComparison comparisonType)

src\libraries\Common\src\System\Reflection\AssemblyNameParser.cs (12)

src\libraries\System.Private.CoreLib\src\System\AppContextConfigHelper.cs (3)

36if (str != null && str.StartsWith("0x", StringComparison.Ordinal)) 139if (str != null && str.StartsWith("0x", StringComparison.Ordinal)) 249if (str != null && str.StartsWith("0x", StringComparison.Ordinal))

src\libraries\System.Private.CoreLib\src\System\Boolean.cs (2)

209return value.Equals(TrueLiteral, StringComparison.OrdinalIgnoreCase); 214return value.Equals(FalseLiteral, StringComparison.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\DebugProvider.cs (1)

59if (message.EndsWith(Environment.NewLineConst, StringComparison.Ordinal))

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

256if (activityName.EndsWith(EventSource.ActivityStartSuffix, StringComparison.Ordinal)) 260else if (activityName.EndsWith(EventSource.ActivityStopSuffix, StringComparison.Ordinal))

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (15)

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\TraceLoggingEventSource.cs (1)

748if (m_traits[i].StartsWith("ETW_", StringComparison.Ordinal))

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

158if (string.IsNullOrEmpty(s_eventSourceNameFilter) || (eventSource.Name.Contains(s_eventSourceNameFilter, StringComparison.OrdinalIgnoreCase))) 176if (string.IsNullOrEmpty(s_eventSourceEventFilter) || (eventData.EventName!.Contains(s_eventSourceEventFilter, StringComparison.OrdinalIgnoreCase)))

src\libraries\System.Private.CoreLib\src\System\Globalization\CultureData.cs (4)

945Name.Equals("zh-CHT", StringComparison.OrdinalIgnoreCase) ? "zh-Hant" : 946Name.Equals("zh-CHS", StringComparison.OrdinalIgnoreCase) ? "zh-Hans" : 2153if (digits.StartsWith("0\uFFFF1\uFFFF2\uFFFF3\uFFFF4\uFFFF5\uFFFF6\uFFFF7\uFFFF8\uFFFF9\uFFFF", StringComparison.Ordinal) || // ICU common cases 2154digits.StartsWith("0123456789", StringComparison.Ordinal)) // NLS common cases

src\libraries\System.Private.CoreLib\src\System\Globalization\CultureData.Icu.cs (2)

44if (name.Length > 1 && (name[0] == '-' || name[0] == '_') && originalName.StartsWith("und", StringComparison.OrdinalIgnoreCase)) 75int collationIndex = name.IndexOf("collation=", i + 1, StringComparison.Ordinal);

src\libraries\System.Private.CoreLib\src\System\Globalization\CultureData.Nls.cs (2)

355if (regionName != null && regionName.Equals(context->regionName, StringComparison.OrdinalIgnoreCase)) 530if (string.Equals(context.strings[i], _sRealName, StringComparison.OrdinalIgnoreCase))

src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeParse.cs (2)

2518raw.hasSameDateAndTimeSeparators = dtfi.DateSeparator.Equals(dtfi.TimeSeparator, StringComparison.Ordinal); 3677if (span.StartsWith(match, StringComparison.OrdinalIgnoreCase))

src\libraries\System.Private.CoreLib\src\System\Globalization\IdnMapping.cs (3)

413if (unicode.AsSpan(iAfterLastDot).StartsWith(c_strAcePrefix, StringComparison.OrdinalIgnoreCase)) 552if (!ascii.Equals(GetAscii(strUnicode), StringComparison.OrdinalIgnoreCase)) 622string.Compare(ascii, iAfterLastDot, c_strAcePrefix, 0, c_strAcePrefix.Length, StringComparison.OrdinalIgnoreCase) != 0)

src\libraries\System.Private.CoreLib\src\System\Globalization\TextInfo.cs (1)

530bool isDutchCulture = CultureName.StartsWith("nl-", StringComparison.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\System\IO\Enumeration\FileSystemName.cs (2)

173return name.EndsWith(expressionEnd, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);

src\libraries\System.Private.CoreLib\src\System\IO\FileSystem.Unix.cs (1)

431!srcNoDirectorySeparator.Equals(destNoDirectorySeparator, StringComparison.OrdinalIgnoreCase) || // different paths.

src\libraries\System.Private.CoreLib\src\System\IO\Path.cs (4)

859private static string GetRelativePath(string relativeTo, string path, StringComparison comparisonType) 869Debug.Assert(comparisonType == StringComparison.Ordinal || comparisonType == StringComparison.OrdinalIgnoreCase); 878int commonLength = PathInternal.GetCommonPathLength(relativeTo, path, ignoreCase: comparisonType == StringComparison.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.Globalization.cs (43)

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.Globalization.Utf8.cs (7)

33internal static bool StartsWithUtf8(this ReadOnlySpan<byte> span, ReadOnlySpan<byte> value, StringComparison comparisonType) 39case StringComparison.CurrentCulture: 40case StringComparison.CurrentCultureIgnoreCase: 45case StringComparison.InvariantCulture: 46case StringComparison.InvariantCultureIgnoreCase: 51case StringComparison.Ordinal: 58Debug.Assert(comparisonType == StringComparison.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\System\Number.Parsing.cs (3)

893internal static bool SpanStartsWith<TChar>(ReadOnlySpan<TChar> span, ReadOnlySpan<TChar> value, StringComparison comparisonType) 986if (SpanStartsWith(valueTrim, positiveSign, StringComparison.OrdinalIgnoreCase)) 1007if (SpanStartsWith(valueTrim, negativeSign, StringComparison.OrdinalIgnoreCase))

src\libraries\System.Private.CoreLib\src\System\OperatingSystem.cs (1)

127return platform.Equals(OSPlatformName, StringComparison.OrdinalIgnoreCase)

src\libraries\System.Private.CoreLib\src\System\Reflection\AssemblyName.cs (1)

305return refName.Equals(defName, StringComparison.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\System\Reflection\ModifiedFunctionPointerType.cs (1)

74if (type.FullName!.StartsWith(CallingConventionTypePrefix, StringComparison.Ordinal))

src\libraries\System.Private.CoreLib\src\System\Reflection\Module.cs (3)

171public static readonly TypeFilter FilterTypeName = (m, c) => FilterTypeNameImpl(m, c!, StringComparison.Ordinal); 172public static readonly TypeFilter FilterTypeNameIgnoreCase = (m, c) => FilterTypeNameImpl(m, c!, StringComparison.OrdinalIgnoreCase); 179private static bool FilterTypeNameImpl(Type cls, object filterCriteria, StringComparison comparison)

src\libraries\System.Private.CoreLib\src\System\Resources\ManifestBasedResourceGroveler.cs (1)

334if (string.Equals(existingName, name, StringComparison.InvariantCultureIgnoreCase))

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceManager.cs (2)

563if (!asmTypeName.AsSpan(0, typeNameLength).Equals(defaultTypeName, StringComparison.Ordinal)) 579return asmTypeName.AsSpan(firstComma + 1, simpleAsmNameLength).Trim().Equals("mscorlib", StringComparison.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\OSPlatform.cs (1)

42return string.Equals(Name, other, StringComparison.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\System\Runtime\Loader\AssemblyDependencyResolver.cs (1)

121!string.Equals(assemblyName.CultureName, NeutralCultureName, StringComparison.OrdinalIgnoreCase))

src\libraries\System.Private.CoreLib\src\System\Runtime\Loader\AssemblyLoadContext.cs (2)

655if (!requestedSimpleName.Equals(runtimeAssembly.GetSimpleName(), StringComparison.InvariantCultureIgnoreCase)) 753if (assemblyName.Name == null || !assemblyName.Name.EndsWith(SatelliteSuffix, StringComparison.Ordinal))

src\libraries\System.Private.CoreLib\src\System\Runtime\Loader\LibraryNameVariation.Unix.cs (1)

29int indexOfSuffix = libName.IndexOf(LibraryNameSuffix, StringComparison.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\System\Runtime\Versioning\FrameworkName.cs (2)

158if (key.Equals(VersionKey, StringComparison.OrdinalIgnoreCase)) 179else if (key.Equals(ProfileKey, StringComparison.OrdinalIgnoreCase))

src\libraries\System.Private.CoreLib\src\System\SearchValues\SearchValues.cs (8)

231/// <param name="comparisonType">Specifies whether to use <see cref="StringComparison.Ordinal"/> or <see cref="StringComparison.OrdinalIgnoreCase"/> search semantics.</param> 233/// <remarks>Only <see cref="StringComparison.Ordinal"/> or <see cref="StringComparison.OrdinalIgnoreCase"/> may be used.</remarks> 234public static SearchValues<string> Create(ReadOnlySpan<string> values, StringComparison comparisonType) 236if (comparisonType is not (StringComparison.Ordinal or StringComparison.OrdinalIgnoreCase)) 241return StringSearchValues.Create(values, ignoreCase: comparisonType == StringComparison.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\System\SearchValues\SearchValues.T.cs (1)

12/// <see cref="SearchValues.Create(ReadOnlySpan{string}, StringComparison)"/>.

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\MultiStringIgnoreCaseSearchValuesFallback.cs (1)

32if (remaining.StartsWith(value, StringComparison.OrdinalIgnoreCase))

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\SingleStringSearchValuesThreeChars.cs (2)

385: _valueState.Value.Equals(value, IgnoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);

src\libraries\System.Private.CoreLib\src\System\Security\SecurityElement.cs (1)

355if (length <= maxCompareLength && string.Compare(strEscValue, 0, str, index, length, StringComparison.Ordinal) == 0)

src\libraries\System.Private.CoreLib\src\System\StartupHookProvider.cs (1)

119if (startupHookPart.EndsWith(DisallowedSimpleAssemblyNameSuffix, StringComparison.OrdinalIgnoreCase))

src\libraries\System.Private.CoreLib\src\System\String.Comparison.cs (64)

src\libraries\System.Private.CoreLib\src\System\String.Manipulation.cs (7)

1196public string Replace(string oldValue, string? newValue, StringComparison comparisonType) => 1199StringComparison.CurrentCulture or StringComparison.CurrentCultureIgnoreCase => ReplaceCore(oldValue, newValue, CultureInfo.CurrentCulture.CompareInfo, GetCaseCompareOfComparisonCulture(comparisonType)), 1200StringComparison.InvariantCulture or StringComparison.InvariantCultureIgnoreCase => ReplaceCore(oldValue, newValue, CompareInfo.Invariant, GetCaseCompareOfComparisonCulture(comparisonType)), 1201StringComparison.Ordinal => Replace(oldValue, newValue), 1202StringComparison.OrdinalIgnoreCase => ReplaceCore(oldValue, newValue, CompareInfo.Invariant, CompareOptions.OrdinalIgnoreCase),

src\libraries\System.Private.CoreLib\src\System\String.Searching.cs (34)

src\libraries\System.Private.CoreLib\src\System\StringComparer.cs (7)

32public static StringComparer FromComparison(StringComparison comparisonType) 36StringComparison.CurrentCulture => CurrentCulture, 37StringComparison.CurrentCultureIgnoreCase => CurrentCultureIgnoreCase, 38StringComparison.InvariantCulture => InvariantCulture, 39StringComparison.InvariantCultureIgnoreCase => InvariantCultureIgnoreCase, 40StringComparison.Ordinal => Ordinal, 41StringComparison.OrdinalIgnoreCase => OrdinalIgnoreCase,

src\libraries\System.Private.CoreLib\src\System\Threading\NamedWaitHandleOptions.cs (2)

127incompatible = !name.StartsWith(CurrentSessionPrefix, StringComparison.Ordinal); 134incompatible = !name.StartsWith(AllSessionsPrefix, StringComparison.Ordinal);

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.cs (6)

654if (string.Equals(id, UtcId, StringComparison.OrdinalIgnoreCase)) 682if (dateTime.Kind == DateTimeKind.Local && string.Equals(sourceTimeZoneId, Local.Id, StringComparison.OrdinalIgnoreCase)) 692else if (dateTime.Kind == DateTimeKind.Utc && string.Equals(sourceTimeZoneId, Utc.Id, StringComparison.OrdinalIgnoreCase)) 859string.Equals(_id, other._id, StringComparison.OrdinalIgnoreCase) && 1020HasIanaId = hasIanaId || _id.Equals(UtcId, StringComparison.OrdinalIgnoreCase); 2138if (!id.Equals(UtcId, StringComparison.OrdinalIgnoreCase))

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.FullGlobalizationData.cs (1)

52if (windowsId.Equals("utc", StringComparison.OrdinalIgnoreCase))

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.FullGlobalizationData.Unix.cs (1)

230if (StringArrayContains(timeZoneId, s_ZonesThatUseLocationName, StringComparison.OrdinalIgnoreCase))

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.cs (9)

39return string.Equals(id, "Etc/UTC", StringComparison.OrdinalIgnoreCase) || 40string.Equals(id, "Etc/UCT", StringComparison.OrdinalIgnoreCase) || 41string.Equals(id, "Etc/Universal", StringComparison.OrdinalIgnoreCase) || 42string.Equals(id, "Etc/Zulu", StringComparison.OrdinalIgnoreCase); 45return string.Equals(id, "UCT", StringComparison.OrdinalIgnoreCase) || 46string.Equals(id, "UTC", StringComparison.OrdinalIgnoreCase) || 47string.Equals(id, "Universal", StringComparison.OrdinalIgnoreCase); 50return string.Equals(id, "Zulu", StringComparison.OrdinalIgnoreCase); 1372private static bool StringArrayContains(string value, string[] source, StringComparison comparison)

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.NonAndroid.cs (4)

254if (symlinkPath.StartsWith(timeZoneDirectory, StringComparison.Ordinal)) 430if (!string.Equals(filePath, localtimeFilePath, StringComparison.OrdinalIgnoreCase) 431&& !string.Equals(filePath, posixrulesFilePath, StringComparison.OrdinalIgnoreCase)) 439if (id.StartsWith(timeZoneDirectory, StringComparison.Ordinal))

src\libraries\System.Private.CoreLib\src\System\Type.cs (2)

738public static readonly MemberFilter FilterName = (m, c) => FilterNameImpl(m, c!, StringComparison.Ordinal); 739public static readonly MemberFilter FilterNameIgnoreCase = (m, c) => FilterNameImpl(m, c!, StringComparison.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\System\Type.Helpers.cs (1)

493private static bool FilterNameImpl(MemberInfo m, object filterCriteria, StringComparison comparison)

src\System\Diagnostics\StackTrace.CoreCLR.cs (1)

37if (!string.Equals(ns, PackageName, StringComparison.Ordinal))

src\System\Reflection\Emit\RuntimeModuleBuilder.cs (1)

186if (string.Equals(name, strTypeName, StringComparison.OrdinalIgnoreCase))

src\System\RuntimeType.CoreCLR.cs (2)

2132if (!memberInfo.Name.StartsWith(name, StringComparison.OrdinalIgnoreCase)) 2137if (!memberInfo.Name.StartsWith(name, StringComparison.Ordinal))

System\Runtime\Serialization\DataContract.cs (3)

614if (!typeName.StartsWith("System.", StringComparison.Ordinal)) 1650if (trimmedNs.Length == 0 || trimmedNs.Contains("##", StringComparison.Ordinal)) 1698return uriString.StartsWith(Globals.DataContractXsdBaseNamespace, StringComparison.Ordinal) ? uriString.Substring(Globals.DataContractXsdBaseNamespace.Length) : uriString;

System\Runtime\Serialization\Json\JsonReaderDelegator.cs (2)

150!dateTimeValue.StartsWith(JsonGlobals.DateTimeStartGuardReader, StringComparison.Ordinal) || 151!dateTimeValue.EndsWith(JsonGlobals.DateTimeEndGuardReader, StringComparison.Ordinal))

System\Runtime\Serialization\Json\XmlJsonWriter.cs (1)

659if (!name.Equals("xml", StringComparison.OrdinalIgnoreCase))

System\Runtime\Serialization\Json\XmlObjectSerializerWriteContextComplexJson.cs (1)

87else if (dataContractNamespace.StartsWith(Globals.DataContractXsdBaseNamespace, StringComparison.Ordinal))

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

729if (xmlReader.NamespaceURI.StartsWith(Globals.DataContractXsdBaseNamespace, StringComparison.Ordinal))

System\Xml\StringHandle.cs (1)

282return string.Compare(this.GetString(), that.GetString(), StringComparison.Ordinal);

System\Xml\XmlCanonicalWriter.cs (1)

254if (string.Equals(Encoding.UTF8.GetString(_xmlnsBuffer!, xmlnsAttribute.prefixOffset, xmlnsAttribute.prefixLength), _inclusivePrefixes[i], StringComparison.Ordinal))

System\DomainNameHelper.cs (3)

80if (span.Equals(Localhost, StringComparison.OrdinalIgnoreCase) || 81span.Equals(Loopback, StringComparison.OrdinalIgnoreCase)) 259if (label.StartsWith("xn--", StringComparison.Ordinal))

System\Uri.cs (22)

System\UriBuilder.cs (5)

271.Replace("/", "%2F", StringComparison.Ordinal) 272.Replace(@"\", "%5C", StringComparison.Ordinal) 273.Replace("?", "%3F", StringComparison.Ordinal) 274.Replace("#", "%23", StringComparison.Ordinal) 275.Replace("@", "%40", StringComparison.Ordinal);

System\UriExt.cs (1)

389StringComparison comparisonType)

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

122if (string.Equals(format, Text, StringComparison.OrdinalIgnoreCase)) 127else if (string.Equals(format, UnicodeText, StringComparison.OrdinalIgnoreCase)) 132else if (string.Equals(format, String, StringComparison.OrdinalIgnoreCase))

System\Private\Windows\Ole\DataFormatsCore.cs (5)

28if (TryFindFormat(s_predefinedFormatList, format, StringComparison.Ordinal, out var found) 29|| TryFindFormat(s_formatList, format, StringComparison.Ordinal, out found) 30|| TryFindFormat(s_predefinedFormatList, format, StringComparison.OrdinalIgnoreCase, out found) 31|| TryFindFormat(s_formatList, format, StringComparison.OrdinalIgnoreCase, out found)) 52StringComparison comparison,

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

133if (format.Equals(formats[i], StringComparison.OrdinalIgnoreCase))

DebuggerAttributes.cs (1)

153bool noQuotes = reference.EndsWith(",nq", StringComparison.Ordinal);

System\Xml\BinaryXml\XmlBinaryReader.cs (1)

1932if (!prefixStr.StartsWith("xmlns", StringComparison.Ordinal))

System\Xml\Core\XmlAutoDetectWriter.cs (1)

358tagName.Equals("html", StringComparison.OrdinalIgnoreCase);

System\Xml\Core\XmlCharCheckingWriter.cs (1)

157while ((i = text.IndexOf("]]>", StringComparison.Ordinal)) >= 0)

System\Xml\Core\XmlCharCheckingWriterAsync.cs (1)

106while ((i = text.IndexOf("]]>", StringComparison.Ordinal)) >= 0)

System\Xml\Core\XmlTextReaderImpl.cs (7)

3229if (string.Equals(newEncodingName, "ucs-2", StringComparison.OrdinalIgnoreCase) || 3230string.Equals(newEncodingName, "utf-16", StringComparison.OrdinalIgnoreCase) || 3231string.Equals(newEncodingName, "iso-10646-ucs-2", StringComparison.OrdinalIgnoreCase) || 3232string.Equals(newEncodingName, "ucs-4", StringComparison.OrdinalIgnoreCase)) 3236!string.Equals(newEncodingName, "ucs-4", StringComparison.OrdinalIgnoreCase)) 3251if (string.Equals(newEncodingName, "utf-8", StringComparison.OrdinalIgnoreCase)) 6210if (string.Equals(target, "xml", StringComparison.OrdinalIgnoreCase))

System\Xml\Core\XmlTextReaderImplAsync.cs (1)

3914if (string.Equals(target, "xml", StringComparison.OrdinalIgnoreCase))

System\Xml\Core\XmlTextReaderImplHelpers.cs (2)

779int result = string.Compare(localName, localName2, StringComparison.Ordinal); 785return string.Compare(prefix, prefix2, StringComparison.Ordinal);

System\Xml\Core\XmlTextWriter.cs (2)

791if (string.Equals(name, "xml", StringComparison.OrdinalIgnoreCase) && _stateTable == s_stateTableDocument) 1774prefix.Equals("xml", StringComparison.OrdinalIgnoreCase) &&

System\Xml\Core\XmlWellFormedWriter.cs (1)

896if (name.Length == 3 && string.Equals(name, "xml", StringComparison.OrdinalIgnoreCase))

System\Xml\Core\XmlWellFormedWriterAsync.cs (1)

797if (name.Length == 3 && string.Equals(name, "xml", StringComparison.OrdinalIgnoreCase))

System\Xml\Dom\XmlImplementation.cs (1)

25if (string.Equals("XML", strFeature, StringComparison.OrdinalIgnoreCase))

System\Xml\Dom\XmlNode.cs (1)

816if (string.Equals("XML", feature, StringComparison.OrdinalIgnoreCase))

System\Xml\Resolvers\XmlPreloadedResolver.cs (2)

196if (relativeUri != null && relativeUri.StartsWith("-//", StringComparison.CurrentCulture)) 201if ((_preloadedDtds & XmlKnownDtds.Xhtml10) != 0 && relativeUri.StartsWith("-//W3C//", StringComparison.CurrentCulture))

System\Xml\Schema\DataTypeImplementation.cs (2)

742public int CompareTo(object? obj) { return string.Compare(_name, (string?)obj, StringComparison.Ordinal); } 1372return string.Compare(value1.ToString(), value2.ToString(), StringComparison.Ordinal);

System\Xml\Schema\Inference\Infer.cs (2)

344if (prefix.Length != 0 && !string.Equals(prefix, "xml", StringComparison.OrdinalIgnoreCase)) 1602if (string.Equals(XmlConvert.ToString(flValue), XmlConvert.ToString(dbValue), StringComparison.OrdinalIgnoreCase))

System\Xml\Schema\XdrBuilder.cs (2)

5520 == string.Compare(uri, 0, x_schema, 0, x_schema.Length, StringComparison.Ordinal) && 553!uri.StartsWith("x-schema:#", StringComparison.Ordinal);

System\Xml\Schema\XmlSchemaDataType.cs (2)

246if (uri.Length > 5 && uri.StartsWith("uuid:", StringComparison.Ordinal)) 250else if (uri.Length > 9 && uri.StartsWith("urn:uuid:", StringComparison.Ordinal))

System\Xml\Schema\XmlSchemaException.cs (1)

83Debug.Assert(message == null || !message.StartsWith("Sch_", StringComparison.Ordinal), "Do not pass a resource here!");

System\Xml\Serialization\CodeIdentifier.cs (1)

260while (identifier.EndsWith("[]", StringComparison.Ordinal))

System\Xml\Serialization\Mappings.cs (1)

240if (!Name.StartsWith("xml:", StringComparison.Ordinal))

System\Xml\Serialization\SchemaObjectWriter.cs (5)

22int ns = string.Compare(a1.NamespaceURI, a2.NamespaceURI, StringComparison.Ordinal); 25return string.Compare(a1.Name, a2.Name, StringComparison.Ordinal); 37return string.Compare($"{f1.GetType().Name}:{f1.Value}", $"{f2.GetType().Name}:{f2.Value}", StringComparison.Ordinal); 47int ns = string.Compare(qn1.Namespace, qn2.Namespace, StringComparison.Ordinal); 50return string.Compare(qn1.Name, qn2.Name, StringComparison.Ordinal);

System\Xml\Serialization\SourceInfo.cs (2)

145if (Arg.StartsWith("o.@", StringComparison.Ordinal) || MemberInfo != null) 147var = ILG.GetVariable(Arg.StartsWith("o.@", StringComparison.Ordinal) ? "o" : Arg);

System\Xml\Serialization\XmlReflectionImporter.cs (1)

1405if (string.Equals(reflectionMembers[i].MemberName, $"{memberName}Specified", StringComparison.Ordinal))

System\Xml\Serialization\XmlSchemaImporter.cs (3)

1423if (member.Name.EndsWith("Specified", StringComparison.Ordinal)) 1472if (member.Name.EndsWith("Specified", StringComparison.Ordinal)) 1792return string.Compare(e1.ToString(string.Empty), e2.ToString(string.Empty), StringComparison.Ordinal);

System\Xml\Serialization\XmlSerializationILGen.cs (1)

579if (source.StartsWith("o.@", StringComparison.Ordinal))

System\Xml\Serialization\XmlSerializationReader.cs (1)

783if (!name.StartsWith("xmlns", StringComparison.Ordinal)) return false;

System\Xml\Serialization\XmlSerializationReaderILGen.cs (8)

System\Xml\Serialization\XmlSerializationWriter.cs (3)

574if (name.Length > prefixLength && name.Length <= prefixLength + MaxInt32.Length && name.StartsWith(prefix, StringComparison.Ordinal)) 953if (localName != "xmlns" && !localName.StartsWith("xmlns:", StringComparison.Ordinal)) 986if (localName != "xmlns" && !localName.StartsWith("xmlns:", StringComparison.Ordinal))

System\Xml\Serialization\XmlSerializationWriterILGen.cs (2)

1042System.Diagnostics.Debug.Assert(xmlnsSource.StartsWith("o.@", StringComparison.Ordinal)); 2499if (initValue.Arg.StartsWith("o.@", StringComparison.Ordinal))

System\Xml\ValidateNames.cs (1)

414s.StartsWith("xml", StringComparison.OrdinalIgnoreCase);

System\Xml\XmlException.cs (1)

92Debug.Assert(message == null || !message.StartsWith("Xml_", StringComparison.Ordinal), "Do not pass a resource here!");

System\Xml\XPath\Internal\BooleanFunctions.cs (1)

82lang.StartsWith(str, StringComparison.OrdinalIgnoreCase) &&

System\Xml\Xsl\IlGen\XmlILTrace.cs (5)

183if (s.StartsWith("Introduce", StringComparison.Ordinal)) 187else if (s.StartsWith("Eliminate", StringComparison.Ordinal)) 191else if (s.StartsWith("Commute", StringComparison.Ordinal)) 195else if (s.StartsWith("Fold", StringComparison.Ordinal)) 199else if (s.StartsWith("Misc", StringComparison.Ordinal))

System\Xml\Xsl\Runtime\XmlExtensionFunction.cs (6)

169StringComparison comparison = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal; 193StringComparison comparison = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;

System\Xml\Xsl\Runtime\XsltFunctions.cs (1)

198if (!lang.StartsWith(value, StringComparison.OrdinalIgnoreCase))

System\Xml\Xsl\XsltOld\AttributeAction.cs (1)

39if (qname.Prefix.StartsWith("xml", StringComparison.Ordinal))

System\Xml\Xsl\XsltOld\ContainerAction.cs (6)

902string.Equals(langName, "jscript", StringComparison.OrdinalIgnoreCase) || 903string.Equals(langName, "javascript", StringComparison.OrdinalIgnoreCase) 909string.Equals(langName, "c#", StringComparison.OrdinalIgnoreCase) || 910string.Equals(langName, "csharp", StringComparison.OrdinalIgnoreCase) 916string.Equals(langName, "vb", StringComparison.OrdinalIgnoreCase) || 917string.Equals(langName, "visualbasic", StringComparison.OrdinalIgnoreCase)

System\Xml\Xsl\XsltOld\ProcessingInstructionAction.cs (1)

152if (nameLength == 3 && name.StartsWith("xml", StringComparison.OrdinalIgnoreCase))

System\Xml\Xsl\XsltOld\SequentialOutput.cs (2)

367if (node.NamespaceURI.Length == 0 && string.Equals("html", node.LocalName, StringComparison.OrdinalIgnoreCase)) 713if (abr && string.Equals(attribute.LocalName, attrValue, StringComparison.OrdinalIgnoreCase))

System\Xml\Xsl\XsltOld\XsltCompileContext.cs (3)

50return string.Compare(baseUri, nextbaseUri, StringComparison.Ordinal); 118if (string.Equals(name, methods[i].Name, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal))

System\Xml\Linq\XProcessingInstruction.cs (1)

162if (string.Equals(name, "xml", StringComparison.OrdinalIgnoreCase)) throw new ArgumentException(SR.Format(SR.Argument_InvalidPIName, name));

System\Reflection\Context\Custom\CustomType.cs (6)

113StringComparison comparison = getIgnoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal; 202StringComparison comparison = getIgnoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;

System\Reflection\Context\Projection\ProjectingType.cs (3)

110StringComparison comparisonType = (bindingAttr & BindingFlags.IgnoreCase) == BindingFlags.IgnoreCase 111? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;

System\Reflection\Emit\ModuleBuilderImpl.cs (3)

1220StringComparison casing = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;

System\Reflection\Emit\TypeBuilderImpl.cs (6)

865StringComparison compare = (bindingFlags & BindingFlags.IgnoreCase) != 0 ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal; 952StringComparison compare = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;

src\libraries\Common\src\System\Reflection\AssemblyNameParser.cs (12)

System\Reflection\Internal\Utilities\MemoryBlock.cs (4)

355return decoded.Equals(text, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal); 379return decoded.StartsWith(text, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);

System\Reflection\Metadata\Ecma335\MetadataBuilder.Heaps.cs (1)

558if (prev.EndsWith(entry.Key, StringComparison.Ordinal) && !BlobUtilities.IsLowSurrogateChar(entry.Key[0]))

System\Reflection\Metadata\Internal\BlobHeap.cs (2)

247return GetDocumentName(handle).Equals(other, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);

System\Reflection\Metadata\Internal\StringHeap.cs (4)

254return string.Equals(GetString(handle, utf8Decoder), value, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal); 273return GetString(handle, utf8Decoder).StartsWith(value, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);

System\Reflection\PortableExecutable\PEHeaders.cs (1)

380if (SectionHeaders[i].Name.Equals(name, StringComparison.Ordinal))

System\Reflection\PathAssemblyResolver.cs (1)

67if (assemblyName.Name.Equals(assemblyNameFromPath.Name, StringComparison.OrdinalIgnoreCase))

System\Reflection\Runtime\BindingFlagSupport\NameFilter.cs (2)

29public sealed override bool Matches(string name) => name.Equals(ExpectedName, StringComparison.Ordinal); 39public sealed override bool Matches(string name) => name.Equals(ExpectedName, StringComparison.OrdinalIgnoreCase);

System\Reflection\TypeLoading\Assemblies\RoAssembly.Modules.cs (1)

123if (name.Equals(candidate.Name, StringComparison.OrdinalIgnoreCase))

System\Reflection\TypeLoading\RuntimeTypeInfo.GetMember.cs (4)

28bool prefixSearch = optionalNameOrPrefix != null && optionalNameOrPrefix.EndsWith("*", StringComparison.Ordinal); 35StringComparison comparisonType = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;

System\Reflection\TypeLoading\Types\RoModifiedFunctionPointerType.cs (1)

74if (type.FullName!.StartsWith(CallingConventionTypePrefix, StringComparison.Ordinal))

System\Reflection\TypeLoading\Types\RoType.GetInterface.cs (1)

22? simpleName.Equals(ifcSimpleName, StringComparison.OrdinalIgnoreCase)

src\libraries\Common\src\System\Resources\ResourceWriter.cs (1)

470if (typeName.StartsWith("ResourceTypeCode.", StringComparison.Ordinal))

System\Resources\Extensions\TypeNameComparer.cs (3)

48return assemblyName.Equals("mscorlib".AsSpan(), StringComparison.OrdinalIgnoreCase); 76if (!type1.Equals(type2, StringComparison.Ordinal)) 99if (!simpleName1.Equals(simpleName2, StringComparison.OrdinalIgnoreCase))

src\libraries\Common\src\System\Resources\ResourceWriter.cs (1)

470if (typeName.StartsWith("ResourceTypeCode.", StringComparison.Ordinal))

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

773[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.StringComparison))]

System\Runtime\Caching\FileChangeNotificationSystem.cs (1)

52return 0 == string.Compare(s1, 0, s2, 0, s2.Length, StringComparison.OrdinalIgnoreCase);

System\Runtime\Caching\MemoryCache.cs (2)

330if (string.Equals(name, "default", StringComparison.OrdinalIgnoreCase)) 348if (string.Equals(name, "default", StringComparison.OrdinalIgnoreCase))

System\Runtime\Caching\MemoryCacheKeyEqualityComparer.cs (1)

20return string.Equals(a.Key, b.Key, StringComparison.Ordinal);

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

130if (string.Equals(existingName, assemblyName, StringComparison.OrdinalIgnoreCase)) 726if (string.Equals(typeName, type.Name, StringComparison.OrdinalIgnoreCase)) 751if (string.Equals(typeName, declaration.Name, StringComparison.OrdinalIgnoreCase)) 1525if (uriString.StartsWith(ImportGlobals.DataContractXsdBaseNamespace, StringComparison.Ordinal))

System\Runtime\Serialization\Schema\SchemaImportHelper.cs (1)

73return uriString.StartsWith(ImportGlobals.DataContractXsdBaseNamespace, StringComparison.Ordinal) ? uriString.Substring(ImportGlobals.DataContractXsdBaseNamespace.Length) : uriString;

System\Security\Claims\Claim.cs (3)

433if (!string.Equals(_valueType, ClaimValueTypes.String, StringComparison.Ordinal)) 439if (!string.Equals(_issuer, ClaimsIdentity.DefaultIssuer, StringComparison.Ordinal)) 445if (string.Equals(_originalIssuer, _issuer, StringComparison.Ordinal))

System\Security\Claims\ClaimsIdentity.cs (6)

582if (string.Equals(claim.Type, type, StringComparison.OrdinalIgnoreCase)) 627if (string.Equals(claim.Type, type, StringComparison.OrdinalIgnoreCase)) 675&& string.Equals(claim.Type, type, StringComparison.OrdinalIgnoreCase) 676&& string.Equals(claim.Value, value, StringComparison.Ordinal)) 815if (!string.Equals(_nameClaimType, ClaimsIdentity.DefaultNameClaimType, StringComparison.Ordinal)) 821if (!string.Equals(_roleClaimType, ClaimsIdentity.DefaultRoleClaimType, StringComparison.Ordinal))

System\Security\Claims\GenericPrincipal.cs (1)

77if (string.Equals(m_roles[i], role, StringComparison.OrdinalIgnoreCase))

src\libraries\Common\src\System\Net\Http\X509ResourceClient.cs (1)

308return string.Equals(scheme, "http", StringComparison.OrdinalIgnoreCase);

src\libraries\Common\src\System\Security\Cryptography\CryptographicAttributeObject.cs (1)

43if (!string.Equals(asn.Oid.Value, oid.Value, StringComparison.Ordinal))

src\libraries\Common\src\System\Security\Cryptography\CryptographicAttributeObjectCollection.cs (2)

57if (string.Equals(szOid1, szOid2, StringComparison.OrdinalIgnoreCase)) 62if (string.Equals(szOid1, Oids.SigningTime, StringComparison.OrdinalIgnoreCase))

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

68if (!string.Equals(Name, other.Name, StringComparison.Ordinal))

System\Security\Cryptography\DSACryptoServiceProvider.Unix.cs (2)

238if (str != null && !string.Equals(str, "SHA1", StringComparison.OrdinalIgnoreCase)) 255if (str != null && !string.Equals(str, "SHA1", StringComparison.OrdinalIgnoreCase))

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

28if (!strName.Equals(HashAlgorithmNames.SHA1, StringComparison.InvariantCultureIgnoreCase))

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

28if (!strName.Equals(HashAlgorithmNames.SHA1, StringComparison.InvariantCultureIgnoreCase))

System\Security\Cryptography\HashAlgorithmNames.cs (5)

53if (hashAlgorithmName.Equals(SHA256, StringComparison.OrdinalIgnoreCase)) 58if (hashAlgorithmName.Equals(SHA384, StringComparison.OrdinalIgnoreCase)) 63if (hashAlgorithmName.Equals(SHA512, StringComparison.OrdinalIgnoreCase)) 68if (hashAlgorithmName.Equals(SHA1, StringComparison.OrdinalIgnoreCase)) 73if (hashAlgorithmName.Equals(MD5, StringComparison.OrdinalIgnoreCase))

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

218string.Equals(aCurve.Oid.FriendlyName, bCurve.Oid.FriendlyName, StringComparison.OrdinalIgnoreCase);

System\Security\Cryptography\Oid.cs (3)

69if (_value != null && !_value.Equals(value, StringComparison.Ordinal)) 96if ((_friendlyName != null && !_friendlyName.Equals(value, StringComparison.Ordinal)) || 124else if (!_value.Equals(oidValue, StringComparison.Ordinal))

System\Security\Cryptography\X509Certificates\ManagedCertificateFinder.cs (2)

73return formedSubject.Contains(subjectName, StringComparison.OrdinalIgnoreCase); 90return formedIssuer.Contains(issuerName, StringComparison.OrdinalIgnoreCase);

System\Security\Cryptography\X509Certificates\OpenSslDirectoryBasedStoreProvider.cs (1)

51Debug.Assert(!X509Store.DisallowedStoreName.Equals(storeName, StringComparison.OrdinalIgnoreCase));

System\Security\Cryptography\X509Certificates\StorePal.OpenSsl.cs (3)

145if (X509Store.DisallowedStoreName.Equals(storeName, StringComparison.OrdinalIgnoreCase)) 166if (X509Store.RootStoreName.Equals(storeName, StringComparison.OrdinalIgnoreCase)) 171if (X509Store.IntermediateCAStoreName.Equals(storeName, StringComparison.OrdinalIgnoreCase))

System\Security\Cryptography\X509Certificates\X500NameEncoder.cs (1)

481bool prefixed = str.StartsWith(OidTagPrefix, StringComparison.OrdinalIgnoreCase);

System\Security\Cryptography\X509Certificates\X509Certificate2.cs (4)

1588/// The "exact" matches performed by this routine are <see cref="StringComparison.OrdinalIgnoreCase"/>, 1708if (embeddedSpan.Slice(2).Equals(afterFirstDot, StringComparison.OrdinalIgnoreCase)) 1713else if (embeddedSpan.Equals(match, StringComparison.OrdinalIgnoreCase)) 1768return hostname.Equals(cn.GetSingleElementValue(), StringComparison.OrdinalIgnoreCase);

System\Security\Cryptography\X509Certificates\X509CertificateLoader.Unix.cs (1)

452_ => certAlgorithm.Equals(keyAlgorithm, StringComparison.Ordinal),

System\Security\Cryptography\X509Certificates\X509ExtensionCollection.cs (1)

57if (string.Equals(extension.Oid!.Value, oidValue, StringComparison.OrdinalIgnoreCase))

src\libraries\Common\src\System\Security\Cryptography\CryptographicAttributeObject.cs (1)

43if (!string.Equals(asn.Oid.Value, oid.Value, StringComparison.Ordinal))

src\libraries\Common\src\System\Security\Cryptography\CryptographicAttributeObjectCollection.cs (2)

57if (string.Equals(szOid1, szOid2, StringComparison.OrdinalIgnoreCase)) 62if (string.Equals(szOid1, Oids.SigningTime, StringComparison.OrdinalIgnoreCase))

System\Security\Cryptography\Xml\SignedXml.cs (4)

337if (string.Equals(extension.Oid!.Value, "2.5.29.15" /* szOID_KEY_USAGE */, StringComparison.OrdinalIgnoreCase)) 671if (string.Equals(safeAlgorithm, SignedInfo!.CanonicalizationMethod, StringComparison.OrdinalIgnoreCase)) 704if (string.Equals(safeAlgorithm, transformAlgorithm, StringComparison.OrdinalIgnoreCase)) 712if (string.Equals(safeAlgorithm, transformAlgorithm, StringComparison.OrdinalIgnoreCase))

System\Security\Cryptography\Xml\Utils.cs (5)

316if (idref.StartsWith("xpointer(id(", StringComparison.Ordinal)) 318int startId = idref.IndexOf("id(", StringComparison.Ordinal); 335if (idref.StartsWith("xpointer(id(", StringComparison.Ordinal)) 337int startId = idref.IndexOf("id(", StringComparison.Ordinal); 743if (string.Equals(certificate.SubjectName.Name, certificate.IssuerName.Name, StringComparison.OrdinalIgnoreCase))

System\Security\Permissions\IDRole.cs (1)

22Authenticated = elAuth == null ? false : string.Equals(elAuth, "true", StringComparison.OrdinalIgnoreCase);

System\Security\Permissions\PrincipalPermission.cs (1)

241(idRole.ID == null || string.Equals(principal.Identity.Name, idRole.ID, StringComparison.OrdinalIgnoreCase)))

System\ServiceModel\Federation\WSTrustUtilities.cs (3)

50if (string.Equals(keyType, serializationContext.TrustKeyTypes.Bearer, StringComparison.Ordinal)) 72if (!string.Equals(keyType, serializationContext.TrustKeyTypes.Symmetric, StringComparison.Ordinal)) 75if (string.Equals(response.RequestedProofToken.ComputedKeyAlgorithm, serializationContext.TrustKeyTypes.PSHA1, StringComparison.Ordinal))

System\ServiceModel\Channels\NetFramingTransportChannelFactory.cs (1)

372if (string.Compare(via.Scheme, Scheme, StringComparison.OrdinalIgnoreCase) != 0)

System\ServiceModel\Channels\TransportSecurityHelpers.cs (1)

105if (!baseAddress.AbsolutePath.EndsWith("/", StringComparison.Ordinal))

System\ServiceModel\Channels\PipeConnectionInitiator.cs (2)

409if (!path.EndsWith("/", StringComparison.Ordinal)) 416if (path.EndsWith("/", StringComparison.Ordinal))

Channels\CommunicationObjectTest.cs (9)

Channels\CustomChannelTest.cs (12)

System\ServiceModel\Syndication\Rss20FeedFormatter.cs (1)

354if (permalinkString != null && permalinkString.Equals("FALSE", StringComparison.InvariantCultureIgnoreCase))

System\Text\EncodingNLS.cs (1)

362if (_encodingName.StartsWith("Globalization_cp_", StringComparison.OrdinalIgnoreCase))

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

119if (!type.IsGenericType || !type.Assembly.FullName!.StartsWith("System.Collections.Immutable", StringComparison.Ordinal)) 137if (!type.IsGenericType || !type.Assembly.FullName!.StartsWith("System.Collections.Immutable", StringComparison.Ordinal))

System\Text\Json\Serialization\Converters\Value\EnumConverter.cs (3)

593Debug.Assert(JsonName.Equals(other.JsonName, StringComparison.OrdinalIgnoreCase), "The conflicting entry must be equal up to case insensitivity."); 632return current.JsonName.Equals(other.JsonName, StringComparison.Ordinal); 638Debug.Assert(input.Equals(JsonName.AsSpan(), StringComparison.OrdinalIgnoreCase), "Must equal the field name up to case insensitivity.");

System\Text\Json\Serialization\Metadata\JsonTypeInfo.cs (1)

1059public bool Equals(ParameterLookupKey other) => Type == other.Type && string.Equals(Name, other.Name, StringComparison.OrdinalIgnoreCase);

System\Text\Json\Serialization\Metadata\PolymorphicTypeResolver.cs (1)

81if (!propertyName.Equals(JsonSerializer.TypePropertyName, StringComparison.Ordinal))

JsonSourceGenerator.Parser.cs (1)

1554=> propSpec.MemberName.Equals(paramSpec.Name, StringComparison.OrdinalIgnoreCase);

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (3)

156var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;

System\Text\RegularExpressions\RegexAssemblyCompiler.cs (1)

231if (!fileName.EndsWith(".dll", StringComparison.Ordinal))

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

331Debug.Assert(string.Compare(s_propTable[i][0], s_propTable[i + 1][0], StringComparison.Ordinal) < 0, $"RegexCharClass s_propTable is out of order at ({s_propTable[i][0]}, {s_propTable[i + 1][0]})"); 1847int res = string.Compare(capname, s_propTable[mid][0], StringComparison.Ordinal);

System\Text\RegularExpressions\RegexCompiler.cs (9)

70private static MethodInfo SpanIndexOfSpanStringComparisonMethod => field ??= typeof(MemoryExtensions).GetMethod("IndexOf", [typeof(ReadOnlySpan<char>), typeof(ReadOnlySpan<char>), typeof(StringComparison)])!; 99private static MethodInfo SpanStartsWithSpanComparisonMethod => field ??= typeof(MemoryExtensions).GetMethod("StartsWith", [typeof(ReadOnlySpan<char>), typeof(ReadOnlySpan<char>), typeof(StringComparison)])!; 779LoadSearchValues(opts.LeadingPrefixes, opts.FindMode is FindNextStartingPositionMode.LeadingStrings_OrdinalIgnoreCase_LeftToRight ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal); 787LoadSearchValues([literalString], opts.FindMode is FindNextStartingPositionMode.LeadingString_OrdinalIgnoreCase_LeftToRight ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal); 1247(RegexNode LoopNode, (char Char, string? String, StringComparison StringComparison, char[]? Chars) Literal) target = _regexTree.FindOptimizations.LiteralAfterLoop.Value; 1273if (target.Literal.StringComparison is StringComparison.OrdinalIgnoreCase) 1280Debug.Assert(target.Literal.StringComparison is StringComparison.Ordinal);

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

181LeadingStrings = SearchValues.Create(LeadingPrefixes, StringComparison.OrdinalIgnoreCase); 217(RegexNode LoopNode, (char Char, string? String, StringComparison StringComparison, char[]? Chars) Literal)? literalAfterLoop = RegexPrefixAnalyzer.FindLiteralFollowingLeadingLoop(root); 336public (RegexNode LoopNode, (char Char, string? String, StringComparison StringComparison, char[]? Chars) Literal)? LiteralAfterLoop { get; } 634int i = textSpan.Slice(pos).IndexOf(LeadingPrefix.AsSpan(), StringComparison.OrdinalIgnoreCase); 820(RegexNode loopNode, (char Char, string? String, StringComparison StringComparison, char[]? Chars) literal) = LiteralAfterLoop.GetValueOrDefault();

System\Text\RegularExpressions\RegexNode.cs (1)

1335Debug.Assert(node.Str.AsSpan().StartsWith(startingSpan, StringComparison.Ordinal));

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

1103public static (RegexNode LoopNode, (char Char, string? String, StringComparison StringComparison, char[]? Chars) Literal)? FindLiteralFollowingLeadingLoop(RegexNode node) 1161prefix.Length == 1 ? (firstChild, (prefix[0], null, StringComparison.Ordinal, null)) : 1162(firstChild, ('\0', prefix, StringComparison.Ordinal, null)); 1192return (firstChild, ('\0', ordinalCaseInsensitivePrefix, StringComparison.OrdinalIgnoreCase, null)); 1223return (firstChild, ('\0', null, StringComparison.Ordinal, chars.ToArray()));

RegexGenerator.Emitter.cs (6)

1095StringComparison stringComparison = opts.FindMode is FindNextStartingPositionMode.LeadingStrings_OrdinalIgnoreCase_LeftToRight ? 1096StringComparison.OrdinalIgnoreCase : 1097StringComparison.Ordinal; 1361(RegexNode LoopNode, (char Char, string? String, StringComparison StringComparison, char[]? Chars) Literal) target = regexTree.FindOptimizations.LiteralAfterLoop.Value; 1366string stringComparisonComment = target.Literal.StringComparison == StringComparison.OrdinalIgnoreCase ? "ordinal case-insensitive " : ""; 1367string stringComparisonArgument = target.Literal.StringComparison == StringComparison.OrdinalIgnoreCase ? ", StringComparison.OrdinalIgnoreCase" : "";

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (3)

156var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexCharClass.cs (2)

331Debug.Assert(string.Compare(s_propTable[i][0], s_propTable[i + 1][0], StringComparison.Ordinal) < 0, $"RegexCharClass s_propTable is out of order at ({s_propTable[i][0]}, {s_propTable[i + 1][0]})"); 1847int res = string.Compare(capname, s_propTable[mid][0], StringComparison.Ordinal);

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexFindOptimizations.cs (2)

217(RegexNode LoopNode, (char Char, string? String, StringComparison StringComparison, char[]? Chars) Literal)? literalAfterLoop = RegexPrefixAnalyzer.FindLiteralFollowingLeadingLoop(root); 336public (RegexNode LoopNode, (char Char, string? String, StringComparison StringComparison, char[]? Chars) Literal)? LiteralAfterLoop { get; }

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexNode.cs (1)

1335Debug.Assert(node.Str.AsSpan().StartsWith(startingSpan, StringComparison.Ordinal));

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexPrefixAnalyzer.cs (5)

1103public static (RegexNode LoopNode, (char Char, string? String, StringComparison StringComparison, char[]? Chars) Literal)? FindLiteralFollowingLeadingLoop(RegexNode node) 1161prefix.Length == 1 ? (firstChild, (prefix[0], null, StringComparison.Ordinal, null)) : 1162(firstChild, ('\0', prefix, StringComparison.Ordinal, null)); 1192return (firstChild, ('\0', ordinalCaseInsensitivePrefix, StringComparison.OrdinalIgnoreCase, null)); 1223return (firstChild, ('\0', null, StringComparison.Ordinal, chars.ToArray()));

UpgradeToGeneratedRegexAnalyzer.cs (4)

174if (argumentName.Equals(timeoutArgumentName, StringComparison.OrdinalIgnoreCase) || 175argumentName.Equals(matchTimeoutArgumentName, StringComparison.OrdinalIgnoreCase)) 181if (argumentName.Equals(PatternArgumentName, StringComparison.OrdinalIgnoreCase)) 204if (argumentName.Equals(OptionsArgumentName, StringComparison.OrdinalIgnoreCase))

System\Threading\RateLimiting\MetadataName.T.cs (1)

56return string.Equals(_name, other._name, StringComparison.Ordinal);

System\Web\Util\UriUtil.cs (1)

42int authorityIndex = inputWithoutQueryFragment.IndexOf(authority, StringComparison.OrdinalIgnoreCase);

Microsoft\Windows\Controls\Ribbon\RibbonComboBox.cs (1)

723if (!String.Equals(newText, matchedText, StringComparison.CurrentCulture))

Microsoft\Windows\Controls\Ribbon\RibbonControlLengthConverter.cs (2)

197if (goodString.EndsWith(_unitStrings[i], StringComparison.Ordinal)) 214if (goodString.EndsWith(_pixelUnitStrings[i], StringComparison.Ordinal))

src\Microsoft.DotNet.Wpf\src\Common\src\System\SR.cs (1)

55if (defaultString is not null && resourceKey.Equals(resourceString, StringComparison.Ordinal))

System\Resources\AssemblyNamesTypeResolutionService.cs (2)

115if (string.Equals(assemblyName.Name, asmName.Name, StringComparison.OrdinalIgnoreCase)) 164if (location.StartsWith(s_dotNetPath, StringComparison.OrdinalIgnoreCase))

System\Resources\ResxFileRef.Converter.cs (1)

137if (toCreate == typeof(Bitmap) && fileName.EndsWith(".ico", StringComparison.Ordinal))

System\Resources\ResXResourceWriter.cs (1)

446if ((type is null && mimeType is null) || (type is not null && type.StartsWith("System.Char", StringComparison.Ordinal)))

System\Resources\ResXSerializationBinder.cs (1)

90typeName = string.Equals(parsed.FullName, serializedType.FullName, StringComparison.Ordinal)

System\Windows\Forms\ActiveX\AxHost.State.cs (2)

93if (string.Equals(enumerator.Name, DataSerializationName, StringComparison.InvariantCultureIgnoreCase)) 109else if (string.Equals(enumerator.Name, PropertyBagSerializationName, StringComparison.InvariantCultureIgnoreCase))

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

2188if (className.Equals(buffer[..length], StringComparison.Ordinal))

System\Windows\Forms\Controls\DataGridView\DataGridView.DataConnection.cs (1)

250if (string.Equals(column.DataPropertyName, sortField.Name, StringComparison.OrdinalIgnoreCase))

System\Windows\Forms\Controls\DataGridView\DataGridView.Methods.cs (3)

7421if (string.Equals(format, DataFormats.Html, StringComparison.OrdinalIgnoreCase)) 7720if (string.Equals(format, DataFormats.Html, StringComparison.OrdinalIgnoreCase)) 8136if (string.Equals(format, DataFormats.Html, StringComparison.OrdinalIgnoreCase))

System\Windows\Forms\Controls\DataGridView\DataGridViewButtonColumn.cs (1)

108if (string.Equals(value, _text, StringComparison.Ordinal))

System\Windows\Forms\Controls\DataGridView\DataGridViewCell.cs (4)

1316if (string.Equals(format, DataFormats.Html, StringComparison.OrdinalIgnoreCase)) 1353bool csv = string.Equals(format, DataFormats.CommaSeparatedValue, StringComparison.OrdinalIgnoreCase); 1355string.Equals(format, DataFormats.Text, StringComparison.OrdinalIgnoreCase) || 1356string.Equals(format, DataFormats.UnicodeText, StringComparison.OrdinalIgnoreCase))

System\Windows\Forms\Controls\DataGridView\DataGridViewColumn.cs (1)

658if (DataGridView is not null && !string.Equals(_name, oldName, StringComparison.Ordinal))

System\Windows\Forms\Controls\DataGridView\DataGridViewColumnCollection.cs (1)

97if (string.Equals(dataGridViewColumn.Name, columnName, StringComparison.OrdinalIgnoreCase))

System\Windows\Forms\Controls\DataGridView\DataGridViewColumnHeaderCell.cs (4)

138if (string.Equals(format, DataFormats.Html, StringComparison.OrdinalIgnoreCase)) 171bool csv = string.Equals(format, DataFormats.CommaSeparatedValue, StringComparison.OrdinalIgnoreCase); 173string.Equals(format, DataFormats.Text, StringComparison.OrdinalIgnoreCase) || 174string.Equals(format, DataFormats.UnicodeText, StringComparison.OrdinalIgnoreCase))

System\Windows\Forms\Controls\DataGridView\DataGridViewHeaderCell.cs (1)

408if (string.Equals(themeFilename, AeroThemeFileName, StringComparison.OrdinalIgnoreCase))

System\Windows\Forms\Controls\DataGridView\DataGridViewLinkColumn.cs (1)

195if (string.Equals(value, _text, StringComparison.Ordinal))

System\Windows\Forms\Controls\DataGridView\DataGridViewRowHeaderCell.cs (4)

108if (string.Equals(format, DataFormats.Html, StringComparison.OrdinalIgnoreCase)) 143bool csv = string.Equals(format, DataFormats.CommaSeparatedValue, StringComparison.OrdinalIgnoreCase); 145string.Equals(format, DataFormats.Text, StringComparison.OrdinalIgnoreCase) || 146string.Equals(format, DataFormats.UnicodeText, StringComparison.OrdinalIgnoreCase))

System\Windows\Forms\Controls\DataGridView\DataGridViewTextBoxEditingControl.cs (3)

153if (Text.IndexOf("\r\n", end, StringComparison.Ordinal) != -1) 163if (!(Text.IndexOf("\r\n", StringComparison.Ordinal) < 0 164|| SelectionStart + SelectionLength < Text.IndexOf("\r\n", StringComparison.Ordinal)))

System\Windows\Forms\Controls\Labels\LinkUtilities.cs (3)

56if (string.Equals(name, IEAnchorColor, StringComparison.OrdinalIgnoreCase)) 60else if (string.Equals(name, IEAnchorColorVisited, StringComparison.OrdinalIgnoreCase)) 64else if (string.Equals(name, IEAnchorColorHover, StringComparison.OrdinalIgnoreCase))

System\Windows\Forms\Controls\ListControl\ListControl.cs (1)

284if (string.Equals(props[i].Name, bindingMemberInfo.BindingField, StringComparison.CurrentCultureIgnoreCase))

System\Windows\Forms\Controls\ListView\ListView.cs (1)

3334if (string.Equals(text, listViewSubItem.Text, StringComparison.OrdinalIgnoreCase))

System\Windows\Forms\Controls\ListView\ListViewGroupCollection.cs (2)

65if (string.Equals(key, this[i].Name, StringComparison.CurrentCulture)) 86if (string.Equals(key, this[i].Name, StringComparison.CurrentCulture))

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\PropertyGridView.cs (2)

1348if (!string.Equals(propertyName, entry.PropertyLabel, StringComparison.InvariantCultureIgnoreCase)) 1523if (text is not null && text.Length > 0 && string.Equals(text[..1], letter, StringComparison.InvariantCultureIgnoreCase))

System\Windows\Forms\Controls\ToolStrips\ProfessionalColorTable.cs (3)

1377if (string.Equals(LunaFileName, themeFileName, StringComparison.OrdinalIgnoreCase)) 1400else if (string.Equals(AeroFileName, themeFileName, StringComparison.OrdinalIgnoreCase)) 1416else if (string.Equals(RoyaleFileName, themeFileName, StringComparison.OrdinalIgnoreCase))

System\Windows\Forms\Controls\ToolStrips\ToolStripManager.cs (2)

152if (string.Equals(toolStrip.Name, toolStripName, StringComparison.Ordinal)) 169if (string.Equals(toolStrip.Name, toolStripName, StringComparison.Ordinal))

System\Windows\Forms\Controls\UpDown\DomainUpDown.cs (1)

297.StartsWith(text, StringComparison.Ordinal);

System\Windows\Forms\DataBinding\Binding.cs (3)

507if (tempPropInfo is null && string.Equals(propInfos[i].Name, PropertyName, StringComparison.OrdinalIgnoreCase)) 516if (tempPropIsNullInfo is null && string.Equals(propInfos[i].Name, propertyNameIsNull, StringComparison.OrdinalIgnoreCase)) 550if (tempValidateInfo is null && string.Equals(eventInfos[i]!.Name, validateName, StringComparison.OrdinalIgnoreCase))

System\Windows\Forms\DataBinding\BindingMemberInfo.cs (1)

48=> string.Equals(BindingMember, other.BindingMember, StringComparison.OrdinalIgnoreCase);

System\Windows\Forms\DataBinding\BindingSource.cs (5)

176if (string.Equals(key, dataMember, StringComparison.OrdinalIgnoreCase)) 269if (string.Equals(value, InnerListFilter, StringComparison.Ordinal)) 306if (string.Equals(value, InnerListSort, StringComparison.InvariantCulture)) 984if (current.EndsWith(" ASC", StringComparison.InvariantCultureIgnoreCase)) 988else if (current.EndsWith(" DESC", StringComparison.InvariantCultureIgnoreCase))

System\Windows\Forms\DataBinding\ControlBindingsCollection.cs (2)

34if (string.Equals(binding.PropertyName, propertyName, StringComparison.OrdinalIgnoreCase)) 198&& string.Equals(binding.PropertyName, current.PropertyName, StringComparison.InvariantCulture))

System\Windows\Forms\Dialogs\CommonDialogs\SpecialFolderEnumConverter.SpecialFolderEnumComparer.cs (1)

16return string.Compare(a?.ToString(), b?.ToString(), StringComparison.InvariantCulture);

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

35if (string.Equals(form.Name, name, StringComparison.OrdinalIgnoreCase))

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

60if (string.Equals(prop.Name, text, StringComparison.OrdinalIgnoreCase))

System\Windows\Forms\SendKeys\SendKeys.cs (3)

282if (value.Equals("JournalHook", StringComparison.OrdinalIgnoreCase)) 286else if (value.Equals("SendInput", StringComparison.OrdinalIgnoreCase)) 352if (string.Equals(s_keywords[i].Keyword, keyword, StringComparison.OrdinalIgnoreCase))

System\Windows\Forms\Analyzers\AppManifestAnalyzer.cs (1)

30if (context.AdditionalFile.Path.EndsWith(".manifest", StringComparison.OrdinalIgnoreCase))

CurrentReferences.cs (1)

82Path.GetFileName(v).StartsWith(major, StringComparison.InvariantCultureIgnoreCase));

System\ComponentModel\Design\DesignerActionPanel.cs (1)

903if (string.Equals(line.FocusId, focusId, StringComparison.Ordinal))

System\ComponentModel\Design\DesignerHost.cs (3)

194if (_rootComponent is not null && string.Equals(component.GetType().FullName, _rootComponentClassName, StringComparison.OrdinalIgnoreCase)) 398if (string.Equals(reflectType.FullName, component.GetType().FullName, StringComparison.Ordinal)) 566if (oldName is not null && className.EndsWith(oldName, StringComparison.Ordinal)

System\ComponentModel\Design\MultilineStringEditor.MultilineStringEditorUI.cs (1)

344int index = windowText.LastIndexOf("\r\n", StringComparison.Ordinal);

System\ComponentModel\Design\ReferenceService.cs (1)

254if (string.Equals(holder.Name, name, StringComparison.OrdinalIgnoreCase))

System\ComponentModel\Design\Serialization\CodeDomDesignerLoader.cs (4)

398if (!string.Equals(docDeclaration.Name, newDecl.Name, caseInsensitive ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal)) 1147if (string.Equals(member.Name, name, StringComparison.OrdinalIgnoreCase)) 1239if (string.Equals(member.Name, name, StringComparison.OrdinalIgnoreCase))

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

368if (!resourceName.AsSpan(0, dotIndex).Equals(ourObjectName, StringComparison.Ordinal)) 908if (methodName.StartsWith("add_", StringComparison.Ordinal))

System\ComponentModel\Design\Serialization\ResourceCodeDomSerializer.cs (1)

37if (string.Equals(methodInvokeEx.Method?.MethodName, "ApplyResources", StringComparison.OrdinalIgnoreCase))

System\ComponentModel\Design\Serialization\ResourceCodeDomSerializer.SerializationResourceManager.cs (1)

753if (expressionName.StartsWith("Set", StringComparison.InvariantCulture))

System\ComponentModel\Design\Serialization\TypeCodeDomSerializer.cs (3)

92StringComparison compare = caseInsensitive ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;

System\Windows\Forms\Design\Behavior\DragAssistanceManager.cs (5)

224if (snapLine.Filter is not null && snapLine.Filter.StartsWith(SnapLine.Padding, StringComparison.Ordinal)) 243if ((snapLine.Filter is not null) && snapLine.Filter.StartsWith(SnapLine.Padding, StringComparison.Ordinal)) 652&& (snapLine.Filter.StartsWith(SnapLine.Margin, StringComparison.Ordinal) 653|| snapLine.Filter.StartsWith(SnapLine.Padding, StringComparison.Ordinal)); 932type = snapLine.Filter!.StartsWith(SnapLine.Margin, StringComparison.Ordinal) ? LineType.Margin : LineType.Padding;

System\Windows\Forms\Design\DataGridViewColumnCollectionDialog.cs (1)

1187if (s is not null && s.Name is not null && string.Equals(s.Name, siteName, StringComparison.OrdinalIgnoreCase) && s.Component != component)

System\Windows\Forms\Design\DesignBinding.cs (1)

43public bool Equals(object? dataSource, string dataMember) => dataSource == DataSource && string.Equals(dataMember, DataMember, StringComparison.OrdinalIgnoreCase);

System\Windows\Forms\Design\DesignBindingPicker.cs (3)

891&& _selectedItem.DataMember.StartsWith(dataMemberNode.DataMember, StringComparison.Ordinal)) 1033string.Equals(descriptor.Name, dataSourceDescriptor.Name, StringComparison.OrdinalIgnoreCase)) 1044string.Equals(descriptor.TypeName, type_.FullName, StringComparison.OrdinalIgnoreCase))

System\Windows\Forms\Design\DocumentDesigner.AxToolboxItem.cs (1)

203if (string.Equals(guid.Value, _clsid, StringComparison.OrdinalIgnoreCase))

System\Windows\Forms\Design\FormDocumentDesigner.cs (1)

204if (snapLines[i] is SnapLine snapLine && snapLine.Filter is not null && snapLine.Filter.StartsWith(SnapLine.Padding, StringComparison.Ordinal))

System\Windows\Forms\Design\ImageListImageEditor.cs (1)

75ImageListImage image = LoadImageFromStream(file, name.EndsWith(".ico", StringComparison.Ordinal));

System\Windows\Forms\Design\MaskDescriptorComparer.cs (1)

62int retVal = string.Compare(textA, textB, StringComparison.CurrentCulture);

System\Windows\Forms\Design\StandardMenuStripVerb.cs (9)

System\Windows\Forms\Design\ToolStripDesignerUtils.cs (1)

180if (currentName.StartsWith("ToolStrip", StringComparison.Ordinal))

System\Windows\Forms\Design\ToolStripTemplateNode.cs (1)

2005if (item is not null && string.Equals(item.Name, CenterLabelName, StringComparison.InvariantCulture) && SystemInformation.HighContrast)

EnsureEditorsTests.cs (1)

177Assert.Contains(attributes, editor => editor.EditorTypeName.StartsWith($"{expectedEditorType.FullName}, ", StringComparison.Ordinal));

System\Windows\Forms\Design\EmbeddedResourceTests.cs (1)

85new(ExpectedIconNamesString.Split(Environment.NewLine).Where(item => !item.EndsWith(".bmp", StringComparison.Ordinal)));

TestHelpers.cs (1)

246while (!currentDirectory.Equals(root, StringComparison.CurrentCultureIgnoreCase))

System\Windows\Forms\Automation\UiaTextRange.cs (3)

304StringComparison comparisonType = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;

Extensions\AssertExtensions.cs (2)

15RuntimeInformation.FrameworkDescription.StartsWith(".NET Framework", StringComparison.Ordinal); 303Assert.Contains(substring, value, StringComparison.Ordinal);

PlatformDetection.Windows.cs (4)

12public static bool IsNetFramework => RuntimeInformation.FrameworkDescription.StartsWith(".NET Framework", StringComparison.OrdinalIgnoreCase); 31public static bool IsWindowsNanoServer => (IsNotWindowsIoTCore && GetInstallationType().Equals("Nano Server", StringComparison.OrdinalIgnoreCase)); 32public static bool IsWindowsServerCore => GetInstallationType().Equals("Server Core", StringComparison.OrdinalIgnoreCase); 124if (e.GetType().FullName.Equals("System.EntryPointNotFoundException", StringComparison.Ordinal))

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

864&& buttonText.Contains($"&{charCode}", StringComparison.OrdinalIgnoreCase);

System\Windows\Forms\DataObjectTests.ClipboardTests.cs (2)

82if (string.IsNullOrWhiteSpace(format) || format == typeof(Bitmap).FullName || format.StartsWith("FileName", StringComparison.Ordinal)) 135if (string.IsNullOrWhiteSpace(format) || format == typeof(Bitmap).FullName || format.StartsWith("FileName", StringComparison.Ordinal))

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

1245if (string.IsNullOrWhiteSpace(format) || format == typeof(Bitmap).FullName || format.StartsWith("FileName", StringComparison.Ordinal)) 1387if (string.IsNullOrWhiteSpace(format) || format == typeof(Bitmap).FullName || format.StartsWith("FileName", StringComparison.Ordinal))

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

191if (CultureInfo.InstalledUICulture.Name.StartsWith("en-", StringComparison.OrdinalIgnoreCase))

System\Windows\Forms\RichTextBoxTests.cs (7)

10559Assert.Contains("RICHEDIT50W", GetClassName(control.HWND), StringComparison.Ordinal); 10568Assert.Contains(".RichEdit.", GetClassName(riched32.HWND), StringComparison.Ordinal); 10573Assert.Contains(".RichEdit20W.", GetClassName(riched20.HWND), StringComparison.Ordinal); 10589int startOfIs = riched20.Text.IndexOf("is", StringComparison.Ordinal); 10590int endOfHidden = riched20.Text.IndexOf("hidden", StringComparison.Ordinal) + "hidden".Length; 10688int startOfSample = richTextBox2.Text.IndexOf("Sample", StringComparison.Ordinal); 10689int endOfText = richTextBox2.Text.IndexOf("text", StringComparison.Ordinal) + "text".Length;

Infra\DataCollectionService.cs (1)

257int binPathSeparator = assemblyDirectory.IndexOf(@"\bin\", StringComparison.Ordinal);

RichTextBoxTests.cs (4)

38Point pt = richTextBox.PointToScreen(richTextBox.GetPositionFromCharIndex(richTextBox.Text.IndexOf("Click link #2", StringComparison.Ordinal))); 98Point pt = richTextBox.PointToScreen(richTextBox.GetPositionFromCharIndex(richTextBox.Text.IndexOf("#link2#custom link", StringComparison.Ordinal))); 159richTextBox.Text.IndexOf("custom link#link2#", StringComparison.Ordinal))); 198control.Select(control.Text.IndexOf(text, StringComparison.Ordinal), text.Length);

src\Microsoft.DotNet.Wpf\src\Common\src\System\SR.cs (1)

55if (defaultString is not null && resourceKey.Equals(resourceString, StringComparison.Ordinal))

src\Microsoft.DotNet.Wpf\src\Common\src\System\SR.cs (1)

55if (defaultString is not null && resourceKey.Equals(resourceString, StringComparison.Ordinal))

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

59int escapedComma = fullName.LastIndexOf("\\,", StringComparison.Ordinal);

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

115if (string.Equals(curAsmName.Name, assemblyName.Name, StringComparison.InvariantCultureIgnoreCase) &&

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\Xaml\Parser\SpecialBracketCharacters.cs (2)

109return _endChars.IndexOf(end.ToString(), StringComparison.Ordinal) == _startChars.IndexOf(start.ToString(), StringComparison.Ordinal);

src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\ReflectionHelper.cs (1)

443Debug.Assert(!assemblyPath.EndsWith(string.Empty + Path.DirectorySeparatorChar, StringComparison.Ordinal), "the assembly path should be a full file path containing file extension");

src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\XmlCompatibilityReader.cs (2)

649if (string.Equals(XmlnsDeclaration, Reader.LocalName, StringComparison.Ordinal)) 655else if (string.Equals(XmlnsDeclaration, Reader.Prefix, StringComparison.Ordinal))

System\Xaml\MS\Impl\KnownStrings.cs (6)

63return string.Equals(a, b, StringComparison.Ordinal); 68return a.Equals(b, StringComparison.Ordinal); 76return src.IndexOf(chars, StringComparison.Ordinal); 84return src.IndexOf(ch, StringComparison.Ordinal); 89return src.EndsWith(target, StringComparison.Ordinal); 94return src.StartsWith(target, StringComparison.Ordinal);

System\Xaml\Parser\MeScanner.cs (1)

244if (value.StartsWith("{}", StringComparison.OrdinalIgnoreCase))

System\Xaml\XamlObjectReader.cs (1)

1750if (name.StartsWith(KnownStrings.ReferenceName, StringComparison.Ordinal))

TaskUsageLogger.cs (4)

380if (String.Equals(name1, name2, StringComparison.OrdinalIgnoreCase)) 387if (parts.Length > 1 && String.Equals(name1, parts[parts.Length - 1], StringComparison.OrdinalIgnoreCase)) 407return String.Equals(projectExtension, ".sln", StringComparison.OrdinalIgnoreCase) || 408String.Equals(projectExtension, ".metaproj", StringComparison.OrdinalIgnoreCase);

BlazorWasmTemplateTest.cs (3)

123Assert.True(serviceWorkerContents.Contains($"/* Manifest version: {serviceWorkerAssetsManifestVersion} */", StringComparison.Ordinal)); 195if (line.Trim().Contains("https://", StringComparison.Ordinal) || line.Trim().Contains("http://", StringComparison.Ordinal))

src\ProjectTemplates\Shared\AspNetProcess.cs (4)

168Assert.True(anchor.PathName.EndsWith(expectedLink, StringComparison.Ordinal), $"Expected next link on {page.Url} to be {expectedLink} but it was {anchor.PathName}: {html.Source.Text}"); 175if (!string.Equals(anchor.Protocol, "https:") || string.Equals(anchor.HostName, "localhost", StringComparison.OrdinalIgnoreCase)) 202ListeningMessagePrefix, StringComparison.Ordinal) + ListeningMessagePrefix.Length); 228if (line.Trim().Contains(ListeningMessagePrefix, StringComparison.Ordinal))

src\ProjectTemplates\Shared\BlazorTemplateTest.cs (2)

60var requiresHttps = string.Equals(auth, "IndividualB2C", StringComparison.OrdinalIgnoreCase) 61|| string.Equals(auth, "SingleOrg", StringComparison.OrdinalIgnoreCase)

src\ProjectTemplates\Shared\Project.cs (4)

271var file = Directory.EnumerateFiles(fullPath).Where(f => f.EndsWith($"{migration}.cs", StringComparison.Ordinal)).FirstOrDefault(); 336if (string.Equals(expectedProfileName, "http", StringComparison.Ordinal)) 341if (string.Equals(expectedProfileName, "https", StringComparison.Ordinal)) 432if (string.Equals(doNotCleanUpTemplates, "false", StringComparison.OrdinalIgnoreCase))

src\ProjectTemplates\Shared\TemplatePackageInstaller.cs (1)

92.Where(p => _templatePackages.Any(t => Path.GetFileName(p).StartsWith(t, StringComparison.OrdinalIgnoreCase)))

src\Shared\CertificateGeneration\CertificateManager.cs (4)

73if (string.Equals(AspNetHttpsOid, extension.Oid?.Value, StringComparison.Ordinal)) 148.Any(e => string.Equals(oid, e.Oid?.Value, StringComparison.Ordinal)); 153.Where(e => string.Equals(AspNetHttpsOid, e.Oid?.Value, StringComparison.Ordinal)) 437if (!string.Equals(certificate.Subject, Subject, StringComparison.Ordinal) || // Kestrel requires this

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

301return hashes.Any(h => string.Equals(h, certificate.Thumbprint, StringComparison.Ordinal));

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

340var prettyCertDir = certDir.StartsWith(homeDirectoryWithSlash, StringComparison.Ordinal) 727var isFirefox = nssDb.Contains("/.mozilla/firefox/", StringComparison.Ordinal);

src\Shared\CommandLineUtils\CommandLine\AnsiConsole.cs (1)

66var escapeIndex = message.IndexOf("\x1b[", escapeScan, StringComparison.Ordinal);

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (8)

158if (arg.StartsWith("--", StringComparison.Ordinal)) 162else if (arg.StartsWith("-", StringComparison.Ordinal)) 171option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.LongName, longOptionName, StringComparison.Ordinal)); 250option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.ShortName, shortOption[0], StringComparison.Ordinal)); 274option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.SymbolName, shortOption[0], StringComparison.Ordinal)); 333if (string.Equals(subcommand.Name, arg, StringComparison.OrdinalIgnoreCase)) 449if (commandName == null || string.Equals(Name, commandName, StringComparison.OrdinalIgnoreCase)) 455target = Commands.SingleOrDefault(cmd => string.Equals(cmd.Name, commandName, StringComparison.OrdinalIgnoreCase));

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (4)

20if (part.StartsWith("--", StringComparison.Ordinal)) 24else if (part.StartsWith("-", StringComparison.Ordinal)) 38else if (part.StartsWith("<", StringComparison.Ordinal) && part.EndsWith(">", StringComparison.Ordinal))

src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

67if (string.Equals(expectedFileName, mainModuleFileName, StringComparison.OrdinalIgnoreCase))

src\ProjectTemplates\Shared\AspNetProcess.cs (4)

168Assert.True(anchor.PathName.EndsWith(expectedLink, StringComparison.Ordinal), $"Expected next link on {page.Url} to be {expectedLink} but it was {anchor.PathName}: {html.Source.Text}"); 175if (!string.Equals(anchor.Protocol, "https:") || string.Equals(anchor.HostName, "localhost", StringComparison.OrdinalIgnoreCase)) 202ListeningMessagePrefix, StringComparison.Ordinal) + ListeningMessagePrefix.Length); 228if (line.Trim().Contains(ListeningMessagePrefix, StringComparison.Ordinal))

src\ProjectTemplates\Shared\BlazorTemplateTest.cs (2)

60var requiresHttps = string.Equals(auth, "IndividualB2C", StringComparison.OrdinalIgnoreCase) 61|| string.Equals(auth, "SingleOrg", StringComparison.OrdinalIgnoreCase)

src\ProjectTemplates\Shared\Project.cs (4)

271var file = Directory.EnumerateFiles(fullPath).Where(f => f.EndsWith($"{migration}.cs", StringComparison.Ordinal)).FirstOrDefault(); 336if (string.Equals(expectedProfileName, "http", StringComparison.Ordinal)) 341if (string.Equals(expectedProfileName, "https", StringComparison.Ordinal)) 432if (string.Equals(doNotCleanUpTemplates, "false", StringComparison.OrdinalIgnoreCase))

src\ProjectTemplates\Shared\TemplatePackageInstaller.cs (1)

92.Where(p => _templatePackages.Any(t => Path.GetFileName(p).StartsWith(t, StringComparison.OrdinalIgnoreCase)))

src\Shared\CertificateGeneration\CertificateManager.cs (4)

73if (string.Equals(AspNetHttpsOid, extension.Oid?.Value, StringComparison.Ordinal)) 148.Any(e => string.Equals(oid, e.Oid?.Value, StringComparison.Ordinal)); 153.Where(e => string.Equals(AspNetHttpsOid, e.Oid?.Value, StringComparison.Ordinal)) 437if (!string.Equals(certificate.Subject, Subject, StringComparison.Ordinal) || // Kestrel requires this

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

301return hashes.Any(h => string.Equals(h, certificate.Thumbprint, StringComparison.Ordinal));

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

340var prettyCertDir = certDir.StartsWith(homeDirectoryWithSlash, StringComparison.Ordinal) 727var isFirefox = nssDb.Contains("/.mozilla/firefox/", StringComparison.Ordinal);

src\Shared\CommandLineUtils\CommandLine\AnsiConsole.cs (1)

66var escapeIndex = message.IndexOf("\x1b[", escapeScan, StringComparison.Ordinal);

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (8)

158if (arg.StartsWith("--", StringComparison.Ordinal)) 162else if (arg.StartsWith("-", StringComparison.Ordinal)) 171option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.LongName, longOptionName, StringComparison.Ordinal)); 250option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.ShortName, shortOption[0], StringComparison.Ordinal)); 274option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.SymbolName, shortOption[0], StringComparison.Ordinal)); 333if (string.Equals(subcommand.Name, arg, StringComparison.OrdinalIgnoreCase)) 449if (commandName == null || string.Equals(Name, commandName, StringComparison.OrdinalIgnoreCase)) 455target = Commands.SingleOrDefault(cmd => string.Equals(cmd.Name, commandName, StringComparison.OrdinalIgnoreCase));

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (4)

20if (part.StartsWith("--", StringComparison.Ordinal)) 24else if (part.StartsWith("-", StringComparison.Ordinal)) 38else if (part.StartsWith("<", StringComparison.Ordinal) && part.EndsWith(">", StringComparison.Ordinal))

src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

67if (string.Equals(expectedFileName, mainModuleFileName, StringComparison.OrdinalIgnoreCase))

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

134if (context?.StartsWith(RoutingTestContext, StringComparison.Ordinal) == true) 145if (context?.StartsWith(StreamingContext, StringComparison.Ordinal) == true) 156!string.Equals(Environment.GetEnvironmentVariable("E2E_TEST_VISIBLE"), "true", StringComparison.OrdinalIgnoreCase))

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

26.Where(ama => ama.Key.StartsWith(TestingOptionsPrefix, StringComparison.Ordinal))

src\ProjectTemplates\Shared\AspNetProcess.cs (4)

168Assert.True(anchor.PathName.EndsWith(expectedLink, StringComparison.Ordinal), $"Expected next link on {page.Url} to be {expectedLink} but it was {anchor.PathName}: {html.Source.Text}"); 175if (!string.Equals(anchor.Protocol, "https:") || string.Equals(anchor.HostName, "localhost", StringComparison.OrdinalIgnoreCase)) 202ListeningMessagePrefix, StringComparison.Ordinal) + ListeningMessagePrefix.Length); 228if (line.Trim().Contains(ListeningMessagePrefix, StringComparison.Ordinal))

src\ProjectTemplates\Shared\BlazorTemplateTest.cs (2)

60var requiresHttps = string.Equals(auth, "IndividualB2C", StringComparison.OrdinalIgnoreCase) 61|| string.Equals(auth, "SingleOrg", StringComparison.OrdinalIgnoreCase)

src\ProjectTemplates\Shared\Project.cs (4)

271var file = Directory.EnumerateFiles(fullPath).Where(f => f.EndsWith($"{migration}.cs", StringComparison.Ordinal)).FirstOrDefault(); 336if (string.Equals(expectedProfileName, "http", StringComparison.Ordinal)) 341if (string.Equals(expectedProfileName, "https", StringComparison.Ordinal)) 432if (string.Equals(doNotCleanUpTemplates, "false", StringComparison.OrdinalIgnoreCase))

src\ProjectTemplates\Shared\TemplatePackageInstaller.cs (1)

92.Where(p => _templatePackages.Any(t => Path.GetFileName(p).StartsWith(t, StringComparison.OrdinalIgnoreCase)))

src\Shared\CertificateGeneration\CertificateManager.cs (4)

73if (string.Equals(AspNetHttpsOid, extension.Oid?.Value, StringComparison.Ordinal)) 148.Any(e => string.Equals(oid, e.Oid?.Value, StringComparison.Ordinal)); 153.Where(e => string.Equals(AspNetHttpsOid, e.Oid?.Value, StringComparison.Ordinal)) 437if (!string.Equals(certificate.Subject, Subject, StringComparison.Ordinal) || // Kestrel requires this

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

301return hashes.Any(h => string.Equals(h, certificate.Thumbprint, StringComparison.Ordinal));

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

340var prettyCertDir = certDir.StartsWith(homeDirectoryWithSlash, StringComparison.Ordinal) 727var isFirefox = nssDb.Contains("/.mozilla/firefox/", StringComparison.Ordinal);

src\Shared\CommandLineUtils\CommandLine\AnsiConsole.cs (1)

66var escapeIndex = message.IndexOf("\x1b[", escapeScan, StringComparison.Ordinal);

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (8)

158if (arg.StartsWith("--", StringComparison.Ordinal)) 162else if (arg.StartsWith("-", StringComparison.Ordinal)) 171option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.LongName, longOptionName, StringComparison.Ordinal)); 250option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.ShortName, shortOption[0], StringComparison.Ordinal)); 274option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.SymbolName, shortOption[0], StringComparison.Ordinal)); 333if (string.Equals(subcommand.Name, arg, StringComparison.OrdinalIgnoreCase)) 449if (commandName == null || string.Equals(Name, commandName, StringComparison.OrdinalIgnoreCase)) 455target = Commands.SingleOrDefault(cmd => string.Equals(cmd.Name, commandName, StringComparison.OrdinalIgnoreCase));

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (4)

20if (part.StartsWith("--", StringComparison.Ordinal)) 24else if (part.StartsWith("-", StringComparison.Ordinal)) 38else if (part.StartsWith("<", StringComparison.Ordinal) && part.EndsWith(">", StringComparison.Ordinal))

src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

67if (string.Equals(expectedFileName, mainModuleFileName, StringComparison.OrdinalIgnoreCase))

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

134if (context?.StartsWith(RoutingTestContext, StringComparison.Ordinal) == true) 145if (context?.StartsWith(StreamingContext, StringComparison.Ordinal) == true) 156!string.Equals(Environment.GetEnvironmentVariable("E2E_TEST_VISIBLE"), "true", StringComparison.OrdinalIgnoreCase))

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

26.Where(ama => ama.Key.StartsWith(TestingOptionsPrefix, StringComparison.Ordinal))

src\ProjectTemplates\Shared\AspNetProcess.cs (4)

168Assert.True(anchor.PathName.EndsWith(expectedLink, StringComparison.Ordinal), $"Expected next link on {page.Url} to be {expectedLink} but it was {anchor.PathName}: {html.Source.Text}"); 175if (!string.Equals(anchor.Protocol, "https:") || string.Equals(anchor.HostName, "localhost", StringComparison.OrdinalIgnoreCase)) 202ListeningMessagePrefix, StringComparison.Ordinal) + ListeningMessagePrefix.Length); 228if (line.Trim().Contains(ListeningMessagePrefix, StringComparison.Ordinal))

src\ProjectTemplates\Shared\BlazorTemplateTest.cs (2)

60var requiresHttps = string.Equals(auth, "IndividualB2C", StringComparison.OrdinalIgnoreCase) 61|| string.Equals(auth, "SingleOrg", StringComparison.OrdinalIgnoreCase)

src\ProjectTemplates\Shared\Project.cs (4)

271var file = Directory.EnumerateFiles(fullPath).Where(f => f.EndsWith($"{migration}.cs", StringComparison.Ordinal)).FirstOrDefault(); 336if (string.Equals(expectedProfileName, "http", StringComparison.Ordinal)) 341if (string.Equals(expectedProfileName, "https", StringComparison.Ordinal)) 432if (string.Equals(doNotCleanUpTemplates, "false", StringComparison.OrdinalIgnoreCase))

src\ProjectTemplates\Shared\TemplatePackageInstaller.cs (1)

92.Where(p => _templatePackages.Any(t => Path.GetFileName(p).StartsWith(t, StringComparison.OrdinalIgnoreCase)))

src\Shared\CertificateGeneration\CertificateManager.cs (4)

73if (string.Equals(AspNetHttpsOid, extension.Oid?.Value, StringComparison.Ordinal)) 148.Any(e => string.Equals(oid, e.Oid?.Value, StringComparison.Ordinal)); 153.Where(e => string.Equals(AspNetHttpsOid, e.Oid?.Value, StringComparison.Ordinal)) 437if (!string.Equals(certificate.Subject, Subject, StringComparison.Ordinal) || // Kestrel requires this

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

301return hashes.Any(h => string.Equals(h, certificate.Thumbprint, StringComparison.Ordinal));

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

340var prettyCertDir = certDir.StartsWith(homeDirectoryWithSlash, StringComparison.Ordinal) 727var isFirefox = nssDb.Contains("/.mozilla/firefox/", StringComparison.Ordinal);

src\Shared\CommandLineUtils\CommandLine\AnsiConsole.cs (1)

66var escapeIndex = message.IndexOf("\x1b[", escapeScan, StringComparison.Ordinal);

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (8)

158if (arg.StartsWith("--", StringComparison.Ordinal)) 162else if (arg.StartsWith("-", StringComparison.Ordinal)) 171option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.LongName, longOptionName, StringComparison.Ordinal)); 250option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.ShortName, shortOption[0], StringComparison.Ordinal)); 274option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.SymbolName, shortOption[0], StringComparison.Ordinal)); 333if (string.Equals(subcommand.Name, arg, StringComparison.OrdinalIgnoreCase)) 449if (commandName == null || string.Equals(Name, commandName, StringComparison.OrdinalIgnoreCase)) 455target = Commands.SingleOrDefault(cmd => string.Equals(cmd.Name, commandName, StringComparison.OrdinalIgnoreCase));

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (4)

20if (part.StartsWith("--", StringComparison.Ordinal)) 24else if (part.StartsWith("-", StringComparison.Ordinal)) 38else if (part.StartsWith("<", StringComparison.Ordinal) && part.EndsWith(">", StringComparison.Ordinal))

src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

67if (string.Equals(expectedFileName, mainModuleFileName, StringComparison.OrdinalIgnoreCase))

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

134if (context?.StartsWith(RoutingTestContext, StringComparison.Ordinal) == true) 145if (context?.StartsWith(StreamingContext, StringComparison.Ordinal) == true) 156!string.Equals(Environment.GetEnvironmentVariable("E2E_TEST_VISIBLE"), "true", StringComparison.OrdinalIgnoreCase))

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

26.Where(ama => ama.Key.StartsWith(TestingOptionsPrefix, StringComparison.Ordinal))

WebApiTemplateTest.cs (2)

221var requiresHttps = string.Equals(auth, "IndividualB2C", StringComparison.OrdinalIgnoreCase) 222|| string.Equals(auth, "SingleOrg", StringComparison.OrdinalIgnoreCase);

BaselineTest.cs (13)

src\ProjectTemplates\Shared\AspNetProcess.cs (4)

168Assert.True(anchor.PathName.EndsWith(expectedLink, StringComparison.Ordinal), $"Expected next link on {page.Url} to be {expectedLink} but it was {anchor.PathName}: {html.Source.Text}"); 175if (!string.Equals(anchor.Protocol, "https:") || string.Equals(anchor.HostName, "localhost", StringComparison.OrdinalIgnoreCase)) 202ListeningMessagePrefix, StringComparison.Ordinal) + ListeningMessagePrefix.Length); 228if (line.Trim().Contains(ListeningMessagePrefix, StringComparison.Ordinal))

src\ProjectTemplates\Shared\BlazorTemplateTest.cs (2)

60var requiresHttps = string.Equals(auth, "IndividualB2C", StringComparison.OrdinalIgnoreCase) 61|| string.Equals(auth, "SingleOrg", StringComparison.OrdinalIgnoreCase)

src\ProjectTemplates\Shared\Project.cs (4)

271var file = Directory.EnumerateFiles(fullPath).Where(f => f.EndsWith($"{migration}.cs", StringComparison.Ordinal)).FirstOrDefault(); 336if (string.Equals(expectedProfileName, "http", StringComparison.Ordinal)) 341if (string.Equals(expectedProfileName, "https", StringComparison.Ordinal)) 432if (string.Equals(doNotCleanUpTemplates, "false", StringComparison.OrdinalIgnoreCase))

src\ProjectTemplates\Shared\TemplatePackageInstaller.cs (1)

92.Where(p => _templatePackages.Any(t => Path.GetFileName(p).StartsWith(t, StringComparison.OrdinalIgnoreCase)))

src\Shared\CertificateGeneration\CertificateManager.cs (4)

73if (string.Equals(AspNetHttpsOid, extension.Oid?.Value, StringComparison.Ordinal)) 148.Any(e => string.Equals(oid, e.Oid?.Value, StringComparison.Ordinal)); 153.Where(e => string.Equals(AspNetHttpsOid, e.Oid?.Value, StringComparison.Ordinal)) 437if (!string.Equals(certificate.Subject, Subject, StringComparison.Ordinal) || // Kestrel requires this

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

301return hashes.Any(h => string.Equals(h, certificate.Thumbprint, StringComparison.Ordinal));

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

340var prettyCertDir = certDir.StartsWith(homeDirectoryWithSlash, StringComparison.Ordinal) 727var isFirefox = nssDb.Contains("/.mozilla/firefox/", StringComparison.Ordinal);

src\Shared\CommandLineUtils\CommandLine\AnsiConsole.cs (1)

66var escapeIndex = message.IndexOf("\x1b[", escapeScan, StringComparison.Ordinal);

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (8)

158if (arg.StartsWith("--", StringComparison.Ordinal)) 162else if (arg.StartsWith("-", StringComparison.Ordinal)) 171option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.LongName, longOptionName, StringComparison.Ordinal)); 250option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.ShortName, shortOption[0], StringComparison.Ordinal)); 274option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.SymbolName, shortOption[0], StringComparison.Ordinal)); 333if (string.Equals(subcommand.Name, arg, StringComparison.OrdinalIgnoreCase)) 449if (commandName == null || string.Equals(Name, commandName, StringComparison.OrdinalIgnoreCase)) 455target = Commands.SingleOrDefault(cmd => string.Equals(cmd.Name, commandName, StringComparison.OrdinalIgnoreCase));

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (4)

20if (part.StartsWith("--", StringComparison.Ordinal)) 24else if (part.StartsWith("-", StringComparison.Ordinal)) 38else if (part.StartsWith("<", StringComparison.Ordinal) && part.EndsWith(">", StringComparison.Ordinal))

src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

67if (string.Equals(expectedFileName, mainModuleFileName, StringComparison.OrdinalIgnoreCase))

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

134if (context?.StartsWith(RoutingTestContext, StringComparison.Ordinal) == true) 145if (context?.StartsWith(StreamingContext, StringComparison.Ordinal) == true) 156!string.Equals(Environment.GetEnvironmentVariable("E2E_TEST_VISIBLE"), "true", StringComparison.OrdinalIgnoreCase))

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

26.Where(ama => ama.Key.StartsWith(TestingOptionsPrefix, StringComparison.Ordinal))

src\RoslynAnalyzers\Utilities\Compiler\AdditionalFileProvider.cs (1)

43=> _additionalFiles.FirstOrDefault(x => Path.GetFileName(x.Path).Equals(fileName, StringComparison.OrdinalIgnoreCase));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\CompilationExtensions.cs (3)

35if (string.Equals(propertyValue?.Trim(), "true", StringComparison.OrdinalIgnoreCase)) 42(propertyValue.Contains(WebAppProjectGuidString, StringComparison.OrdinalIgnoreCase) || 43propertyValue.Contains(WebSiteProjectGuidString, StringComparison.OrdinalIgnoreCase)))

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (8)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IPropertySymbolExtensions.cs (1)

28|| !property.Name.Equals("IsCompleted", StringComparison.Ordinal)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (1)

840=> symbol?.Name.StartsWith("_", StringComparison.Ordinal) == true &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\StringExtensions.cs (1)

24return str.EndsWith(suffix, StringComparison.Ordinal);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\UriExtensions.cs (1)

38if (symbol.Name.Contains(word, StringComparison.OrdinalIgnoreCase))

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

403if (!genericInterfaceFullName.StartsWith("T:", StringComparison.Ordinal)) 478(optionValue == null || !optionValue.Contains(arg.optionForcedValue, StringComparison.Ordinal))) 505(optionValue == null || !optionValue.Contains(optionForcedValue, StringComparison.Ordinal)))

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (12)

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (2)

166if (xtext.Value.Contains("\r", StringComparison.Ordinal) || xtext.Value.Contains("\n", StringComparison.Ordinal))

src\RoslynAnalyzers\Utilities\Compiler\WordParser.cs (1)

250if (string.Equals(parsedWord, word, StringComparison.OrdinalIgnoreCase))

TestProgram.cs (1)

27if (args[i].StartsWith("--skip-resources", StringComparison.InvariantCultureIgnoreCase))

EnumsShouldHavePluralNames.cs (3)

85if (symbol.Name.EndsWith("i", StringComparison.OrdinalIgnoreCase) || symbol.Name.EndsWith("ae", StringComparison.OrdinalIgnoreCase)) 115=> word.Equals(word.Pluralize(inputIsKnownToBeSingular: false), StringComparison.OrdinalIgnoreCase);

IdentifiersShouldBeSpelledCorrectly.cs (1)

272var isXml = additionalText.Path.EndsWith(".xml", StringComparison.OrdinalIgnoreCase);

src\RoslynAnalyzers\Utilities\Compiler\AdditionalFileProvider.cs (1)

43=> _additionalFiles.FirstOrDefault(x => Path.GetFileName(x.Path).Equals(fileName, StringComparison.OrdinalIgnoreCase));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

142var index = symbolName.LastIndexOf(".", StringComparison.OrdinalIgnoreCase);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\CompilationExtensions.cs (3)

35if (string.Equals(propertyValue?.Trim(), "true", StringComparison.OrdinalIgnoreCase)) 42(propertyValue.Contains(WebAppProjectGuidString, StringComparison.OrdinalIgnoreCase) || 43propertyValue.Contains(WebSiteProjectGuidString, StringComparison.OrdinalIgnoreCase)))

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (8)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IPropertySymbolExtensions.cs (1)

28|| !property.Name.Equals("IsCompleted", StringComparison.Ordinal)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (1)

840=> symbol?.Name.StartsWith("_", StringComparison.Ordinal) == true &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\StringExtensions.cs (1)

24return str.EndsWith(suffix, StringComparison.Ordinal);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\UriExtensions.cs (1)

38if (symbol.Name.Contains(word, StringComparison.OrdinalIgnoreCase))

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

403if (!genericInterfaceFullName.StartsWith("T:", StringComparison.Ordinal)) 478(optionValue == null || !optionValue.Contains(arg.optionForcedValue, StringComparison.Ordinal))) 505(optionValue == null || !optionValue.Contains(optionForcedValue, StringComparison.Ordinal)))

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (12)

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (2)

166if (xtext.Value.Contains("\r", StringComparison.Ordinal) || xtext.Value.Contains("\n", StringComparison.Ordinal))

src\RoslynAnalyzers\Utilities\Compiler\WordParser.cs (1)

250if (string.Equals(parsedWord, word, StringComparison.OrdinalIgnoreCase))

MS\Internal\Automation\Misc.cs (1)

216return className.IndexOf("windowsforms", StringComparison.OrdinalIgnoreCase) > -1;

MS\Internal\Automation\ProxyManager.cs (4)

265if (string.Equals(className, str, StringComparison.OrdinalIgnoreCase)) 283if (parentClassName.StartsWith("WMP9ActiveXHost", StringComparison.OrdinalIgnoreCase)) 666if (classNameForPartialMatch.Contains(pi.ClassName, StringComparison.Ordinal)) 673if (classNameForPartialMatch.Contains(pi.ClassName, StringComparison.Ordinal)

MS\Internal\Automation\WindowShowOrOpenTracker.cs (1)

74if (string.Compare(str, 0, _wcpClassName, 0, _wcpClassName.Length, StringComparison.OrdinalIgnoreCase) == 0)

src\Microsoft.DotNet.Wpf\src\Common\src\System\SR.cs (1)

55if (defaultString is not null && resourceKey.Equals(resourceString, StringComparison.Ordinal))

MS\Internal\AutomationProxies\MSAANativeProvider.cs (2)

364if (string.Equals(className, "eHome Render Window", StringComparison.OrdinalIgnoreCase)) 1063if (string.Equals(className, str, StringComparison.OrdinalIgnoreCase))

MS\Internal\AutomationProxies\WindowsComboBox.cs (1)

672return string.Equals(Misc.GetClassName(hwndEx), ComboboxEx32, StringComparison.OrdinalIgnoreCase);

MS\Internal\AutomationProxies\WindowsContainer.cs (1)

34else if (className.Contains("AfxControlBar", StringComparison.Ordinal))

MS\Internal\AutomationProxies\WindowsEditBoxRange.cs (2)

210int i = backwards ? rangeText.LastIndexOf(text, StringComparison.Ordinal) : rangeText.IndexOf(text, StringComparison.Ordinal);

MS\Internal\AutomationProxies\WindowsFormsHelpers.cs (1)

123return className.IndexOf(_WindowsFormsClassName, StringComparison.OrdinalIgnoreCase) > -1;

MS\Internal\AutomationProxies\WindowsHyperlink.cs (1)

284if (text.IndexOf("<A", StringComparison.OrdinalIgnoreCase) < 0)

MS\Internal\AutomationProxies\WindowsListView.cs (1)

1642return string.Equals(className, "DesktopSFTBarHost", StringComparison.OrdinalIgnoreCase);

MS\Internal\AutomationProxies\WindowsMenu.cs (5)

911return string.Equals(Misc.ProxyGetClassName(hwnd), WindowsMenu.MenuClassName, StringComparison.OrdinalIgnoreCase); 1342pos = menuText.LastIndexOf(accelerator, StringComparison.OrdinalIgnoreCase); 1360pos = menuText.LastIndexOf(keywordsAccelerators[i], StringComparison.OrdinalIgnoreCase); 2440if ((pos = menuText.LastIndexOf(sKeyword, StringComparison.Ordinal)) >= 0 && pos + cKeyChars + 2 <= cMenuChars) 2774pos = menuText.LastIndexOf(keywordsAccelerators[i], StringComparison.OrdinalIgnoreCase);

MS\Internal\AutomationProxies\WindowsRichEditRange.cs (1)

724if (!string.Equals(name, unitRange.Font.Name, StringComparison.Ordinal))

MS\Internal\AutomationProxies\WindowsScroll.cs (3)

161if (className.StartsWith("RichEdit", StringComparison.OrdinalIgnoreCase) || 162className.StartsWith("WindowForms10.RichEdit", StringComparison.OrdinalIgnoreCase) || 163string.Equals(className, "Edit", StringComparison.OrdinalIgnoreCase))

MS\Internal\AutomationProxies\WindowsSpinner.cs (2)

66if (!Misc.ProxyGetClassName(hwndBuddy).Contains("EDIT", StringComparison.OrdinalIgnoreCase)) 280if (className.Contains("msctls_updown32", StringComparison.OrdinalIgnoreCase))

MS\Internal\AutomationProxies\WindowsSysHeader.cs (2)

78if (Misc.GetClassName(hwndParent).Contains("SysListView32", StringComparison.Ordinal)) 247if (Misc.GetClassName(hwndParent).Contains("SysListView32", StringComparison.Ordinal))

MS\Internal\AutomationProxies\WindowsTab.cs (1)

760if (className.IndexOf("updown", StringComparison.Ordinal) > -1)

MS\Internal\AutomationProxies\WindowsTooltip.cs (5)

175return string.Equals(className, "tooltips_class32", StringComparison.OrdinalIgnoreCase) || 176string.Equals(className, CLASS_TITLEBAR_TOOLTIP, StringComparison.OrdinalIgnoreCase) || 177string.Equals(className, "VBBubble", StringComparison.OrdinalIgnoreCase); 184if (string.Equals(className, CLASS_TITLEBAR_TOOLTIP, StringComparison.OrdinalIgnoreCase)) 188else if (string.Equals(className, "VBBubble", StringComparison.OrdinalIgnoreCase))

MS\Internal\AutomationProxies\WindowsUpDown.cs (1)

368return hwndBuddy != IntPtr.Zero && Misc.ProxyGetClassName(hwndBuddy).Contains("EDIT", StringComparison.OrdinalIgnoreCase);

MS\Internal\AutomationProxies\WinFormsSpinner.cs (2)

154if (Misc.ProxyGetClassName(hwndLastChild).Contains("Edit", StringComparison.OrdinalIgnoreCase)) 162if (Misc.ProxyGetClassName(hwndFirstChild).Contains("Edit", StringComparison.OrdinalIgnoreCase))

src\Microsoft.DotNet.Wpf\src\Common\src\System\SR.cs (1)

55if (defaultString is not null && resourceKey.Equals(resourceString, StringComparison.Ordinal))

src\Microsoft.DotNet.Wpf\src\Common\src\System\SR.cs (1)

55if (defaultString is not null && resourceKey.Equals(resourceString, StringComparison.Ordinal))

src\Microsoft.DotNet.Wpf\src\Common\src\System\SR.cs (1)

55if (defaultString is not null && resourceKey.Equals(resourceString, StringComparison.Ordinal))

src\Compilers\Server\VBCSCompiler\BuildServerController.cs (1)

176if (arg.StartsWith(pipeArgPrefix, StringComparison.Ordinal))

src\Compilers\Server\VBCSCompiler\ClientConnectionHandler.cs (1)

55if (!string.Equals(request.CompilerHash, BuildProtocolConstants.GetCommitHash(), StringComparison.OrdinalIgnoreCase))

CompilerServerTests.cs (15)

src\Shared\CommandLineUtils\CommandLine\AnsiConsole.cs (1)

66var escapeIndex = message.IndexOf("\x1b[", escapeScan, StringComparison.Ordinal);

src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (8)

158if (arg.StartsWith("--", StringComparison.Ordinal)) 162else if (arg.StartsWith("-", StringComparison.Ordinal)) 171option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.LongName, longOptionName, StringComparison.Ordinal)); 250option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.ShortName, shortOption[0], StringComparison.Ordinal)); 274option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.SymbolName, shortOption[0], StringComparison.Ordinal)); 333if (string.Equals(subcommand.Name, arg, StringComparison.OrdinalIgnoreCase)) 449if (commandName == null || string.Equals(Name, commandName, StringComparison.OrdinalIgnoreCase)) 455target = Commands.SingleOrDefault(cmd => string.Equals(cmd.Name, commandName, StringComparison.OrdinalIgnoreCase));

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (4)

20if (part.StartsWith("--", StringComparison.Ordinal)) 24else if (part.StartsWith("-", StringComparison.Ordinal)) 38else if (part.StartsWith("<", StringComparison.Ordinal) && part.EndsWith(">", StringComparison.Ordinal))

src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

67if (string.Equals(expectedFileName, mainModuleFileName, StringComparison.OrdinalIgnoreCase))

src\Microsoft.DotNet.Wpf\src\Common\src\System\SR.cs (1)

55if (defaultString is not null && resourceKey.Equals(resourceString, StringComparison.Ordinal))

RichTextBoxes.cs (1)

41control.Select(control.Text.IndexOf(text, StringComparison.Ordinal), text.Length);

ItemGroupParser.cs (1)

58if (line.EndsWith("=", StringComparison.Ordinal))

PropertyAsserts.cs (2)

47 propertyChangeHappened = propertyChangeHappened || string.IsNullOrEmpty(args.PropertyName) || propertyName.Equals(args.PropertyName, StringComparison.OrdinalIgnoreCase); 94 propertyChangeHappened = propertyChangeHappened || string.IsNullOrEmpty(args.PropertyName) || propertyName.Equals(args.PropertyName, StringComparison.OrdinalIgnoreCase);

Sdk\ArgumentFormatter.cs (4)

371 value.ToString()?.Replace(", ", " | ", StringComparison.Ordinal) ?? "null"; 435 value = EscapeString(value).Replace(@"""", @"\""", StringComparison.Ordinal); // escape double quotes 518 var tickIdx = result.IndexOf('`', StringComparison.Ordinal); 602 return typeInfo.Name.Contains("AnonymousType", StringComparison.Ordinal);

Sdk\Exceptions\AllException.cs (2)

66 error.Item2.Replace(Environment.NewLine, wrapSpaces, StringComparison.Ordinal), 73 error.Item3.Message.Replace(Environment.NewLine, wrapSpaces, StringComparison.Ordinal)

Sdk\Exceptions\EqualException.cs (2)

240 expectedText.Replace(Environment.NewLine, newLineAndIndent, StringComparison.Ordinal), 246 actualText.Replace(Environment.NewLine, newLineAndIndent, StringComparison.Ordinal)

StringAsserts.cs (104)

CommandLine.cs (11)

common\AssemblyResolution\DependencyContextAssemblyCache.cs (4)

102=> runtimeGraph.FirstOrDefault(x => string.Equals(x.Runtime, currentRuntimeIdentifier, StringComparison.OrdinalIgnoreCase)) 103?? runtimeGraph.FirstOrDefault(x => string.Equals(x.Runtime, fallbackRuntimeIdentifier.Value, StringComparison.OrdinalIgnoreCase)) 238var resolvedAssemblyPath = assemblies.FirstOrDefault(a => string.Equals(assemblyName, Path.GetFileNameWithoutExtension(a), StringComparison.OrdinalIgnoreCase)); 281var resolvedAssemblyPath = assemblies.FirstOrDefault(a => string.Equals(formattedUnmanagedDllName, Path.GetFileName(a), StringComparison.OrdinalIgnoreCase));

common\AssemblyResolution\Microsoft.DotNet.PlatformAbstractions\Native\PlatformApis.cs (2)

107if (line.StartsWith("ID=", StringComparison.Ordinal)) 111else if (line.StartsWith("VERSION_ID=", StringComparison.Ordinal))

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\Resolution\AppBaseCompilationAssemblyResolver.cs (5)

37var isProject = string.Equals(library.Type, "project", StringComparison.OrdinalIgnoreCase) || 38string.Equals(library.Type, "msbuildproject", StringComparison.OrdinalIgnoreCase); 40var isPackage = string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase); 41var isReferenceAssembly = string.Equals(library.Type, "referenceassembly", StringComparison.OrdinalIgnoreCase); 45!string.Equals(library.Type, "reference", StringComparison.OrdinalIgnoreCase))

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\Resolution\PackageCompilationAssemblyResolver.cs (1)

81!string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase))

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\Resolution\ReferenceAssemblyPathResolver.cs (1)

43if (!string.Equals(library.Type, "referenceassembly", StringComparison.OrdinalIgnoreCase))

common\AssemblyResolution\XunitPackageCompilationAssemblyResolver.cs (1)

66if (nugetPackageDirectories.Count == 0 || !string.Equals(library.Type, "package", StringComparison.OrdinalIgnoreCase))

ConsoleRunner.cs (1)

61if (!defaultDirectory.EndsWith(new string(new[] { Path.DirectorySeparatorChar }), StringComparison.Ordinal))