IsWhiteSpace

339 references to IsWhiteSpace

Aspire.Dashboard (1)

src\Shared\ConsoleLogs\TimestampParser.cs (1)

31if (char.IsWhiteSpace(content[0]))

Aspire.Hosting (1)

src\Shared\ConsoleLogs\TimestampParser.cs (1)

31if (char.IsWhiteSpace(content[0]))

Aspire.Hosting.Docker (1)

EnvVarEscaper.cs (1)

216if (!char.IsWhiteSpace(c))

dotnet-svcutil.xmlserializer (2)

Microsoft\Tools\ServiceModel\SvcUtil\ToolConsole.cs (2)

526while ((index < text.Length) && char.IsWhiteSpace(text[index])) 591if (char.IsWhiteSpace(text[end]))

dotnet-svcutil-lib (6)

FrameworkFork\Microsoft.CodeDom\System\CodeTypeReference.cs (2)

440while (start < typeName.Length && Char.IsWhiteSpace(typeName[start])) start++; 441while (end >= 0 && Char.IsWhiteSpace(typeName[end])) end--;

FrameworkFork\Microsoft.Xml\Xml\schema\XsdDateTime.cs (2)

746while (start < _length && char.IsWhiteSpace(text[start])) 1042while (start < _length && char.IsWhiteSpace(_text[start]))

HelpGenerator.cs (2)

348while ((index < text.Length) && char.IsWhiteSpace(text[index])) 413if (char.IsWhiteSpace(text[end]))

illink (2)

Linker\Driver.cs (2)

125 while (char.IsWhiteSpace ((char) cur)) { 162 if (cur < 0 || (!inquote && char.IsWhiteSpace ((char) cur)))

Microsoft.Analyzers.Local (1)

ApiLifecycle\Json\TextScanner.cs (1)

89if (char.IsWhiteSpace(next))

Microsoft.AspNetCore.App.Analyzers (2)

Infrastructure\VirtualChars\TextLineExtensions.cs (1)

17if (!char.IsWhiteSpace(text[i]))

Infrastructure\VirtualChars\VirtualChar.cs (1)

101=> SurrogateChar != 0 ? char.IsWhiteSpace(SurrogateChar) : Rune.IsWhiteSpace(Rune);

Microsoft.AspNetCore.Http.Abstractions (1)

Internal\HeaderSegmentCollection.cs (1)

181Attr attr = char.IsWhiteSpace(ch) ? Attr.Whitespace : ch == '\"' ? Attr.Quote : (ch == ',' || ch == (char)0) ? Attr.Delimiter : Attr.Value;

Microsoft.AspNetCore.OpenApi.SourceGenerators (1)

Helpers\StringExtensions.cs (1)

35while (leadingWhitespace < line.Length && char.IsWhiteSpace(line[leadingWhitespace]))

Microsoft.AspNetCore.Razor (1)

TagHelpers\DefaultTagHelperContent.cs (1)

317if (IsEmptyOrWhiteSpace && !char.IsWhiteSpace(value))

Microsoft.Build (14)

BuildCheck\Checks\ExecCliBuildCheck.cs (2)

121if (char.IsWhiteSpace(c) && (normalizedCommandIndex == 0 || char.IsWhiteSpace(normalizedBuildCommand[normalizedCommandIndex - 1])))

BuildCheck\Infrastructure\EditorConfig\EditorConfigFile.cs (1)

139if (!char.IsWhiteSpace(c))

EscapingUtilities.cs (2)

83while (currentPosition < escapedString.Length && Char.IsWhiteSpace(escapedString[currentPosition])) 91while (Char.IsWhiteSpace(escapedString[escapedStringLength - 1]))

Evaluation\Conditionals\Scanner.cs (2)

361else if (char.IsWhiteSpace(character)) 766while (_parsePoint < _expression.Length && char.IsWhiteSpace(_expression[_parsePoint]))

Evaluation\Expander.cs (2)

1363if (Char.IsWhiteSpace(propertyBody[0]) || Char.IsWhiteSpace(propertyBody[propertyBody.Length - 1]))

Evaluation\ExpressionShredder.cs (1)

680while (i < expression.Length && Char.IsWhiteSpace(expression[i]))

Evaluation\SemiColonTokenizer.cs (2)

143while (startIndex < endIndex && char.IsWhiteSpace(_expression[startIndex])) 147while (startIndex < endIndex && char.IsWhiteSpace(_expression[endIndex - 1]))

ResourceUtilities.cs (2)

48while (i < message.Length && Char.IsWhiteSpace(message[i])) 118while (i < message.Length && Char.IsWhiteSpace(message[i]))

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

EscapingUtilities.cs (2)

83while (currentPosition < escapedString.Length && Char.IsWhiteSpace(escapedString[currentPosition])) 91while (Char.IsWhiteSpace(escapedString[escapedStringLength - 1]))

ResourceUtilities.cs (2)

48while (i < message.Length && Char.IsWhiteSpace(message[i])) 118while (i < message.Length && Char.IsWhiteSpace(message[i]))

Microsoft.Build.Framework.UnitTests (4)

EscapingUtilities.cs (2)

83while (currentPosition < escapedString.Length && Char.IsWhiteSpace(escapedString[currentPosition])) 91while (Char.IsWhiteSpace(escapedString[escapedStringLength - 1]))

ResourceUtilities.cs (2)

48while (i < message.Length && Char.IsWhiteSpace(message[i])) 118while (i < message.Length && Char.IsWhiteSpace(message[i]))

Microsoft.Build.Tasks.CodeAnalysis (2)

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

69while (i < commandLine.Length && char.IsWhiteSpace(commandLine[i])) 86while (i < commandLine.Length && (!char.IsWhiteSpace(commandLine[i]) || (quoteCount % 2 != 0)))

Microsoft.Build.Tasks.Core (6)

CSharptokenCharReader.cs (1)

126while (!EndOfLines && Char.IsWhiteSpace(CurrentCharacter))

EscapingUtilities.cs (2)

83while (currentPosition < escapedString.Length && Char.IsWhiteSpace(escapedString[currentPosition])) 91while (Char.IsWhiteSpace(escapedString[escapedStringLength - 1]))

ResourceUtilities.cs (2)

48while (i < message.Length && Char.IsWhiteSpace(message[i])) 118while (i < message.Length && Char.IsWhiteSpace(message[i]))

VisualBasictokenCharReader.cs (1)

142if (Char.IsWhiteSpace(CurrentCharacter) && !TokenChar.IsNewLine(CurrentCharacter))

Microsoft.Build.Tasks.UnitTests (1)

QuotingUtilities.cs (1)

116(((separators.Length == 0) && char.IsWhiteSpace(input[i])) ||

Microsoft.Build.Utilities.Core (4)

EscapingUtilities.cs (2)

83while (currentPosition < escapedString.Length && Char.IsWhiteSpace(escapedString[currentPosition])) 91while (Char.IsWhiteSpace(escapedString[escapedStringLength - 1]))

ResourceUtilities.cs (2)

48while (i < message.Length && Char.IsWhiteSpace(message[i])) 118while (i < message.Length && Char.IsWhiteSpace(message[i]))

Microsoft.CodeAnalysis (8)

CommandLine\AnalyzerConfig.cs (1)

286if (!char.IsWhiteSpace(c))

CommandLine\CommandLineParser.cs (1)

329if (!char.IsWhiteSpace(c) && c != '.')

InternalUtilities\CommandLineUtilities.cs (2)

69while (i < commandLine.Length && char.IsWhiteSpace(commandLine[i])) 86while (i < commandLine.Length && (!char.IsWhiteSpace(commandLine[i]) || (quoteCount % 2 != 0)))

MemoryExtensions.cs (1)

82if (!char.IsWhiteSpace(c))

MetadataReader\MetadataHelpers.cs (3)

245if (!EndOfInput && Char.IsWhiteSpace(Current)) 340if (!EndOfInput && Char.IsWhiteSpace(Current)) 1009if (char.IsWhiteSpace(name[0]))

Microsoft.CodeAnalysis.Analyzers (1)

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer_IdRangeAndCategoryValidation.cs (1)

260category.Any(char.IsWhiteSpace) || // We do not allow white spaces in category name.

Microsoft.CodeAnalysis.CodeStyle (10)

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

127if (!char.IsWhiteSpace(c))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualChar.cs (1)

99=> SurrogateChar != 0 ? char.IsWhiteSpace(SurrogateChar) : Rune.IsWhiteSpace(Rune);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\StringExtensions.cs (2)

20if (!char.IsWhiteSpace(line[i])) 35if (!char.IsWhiteSpace(line[i]))

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

19if (!char.IsWhiteSpace(text[i])) 51if (!char.IsWhiteSpace(text[i])) 71if (!char.IsWhiteSpace(text[i]))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (1)

503if (!char.IsWhiteSpace(this.OriginalString[i]))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (2)

185=> tokenText.Length > 0 && char.IsWhiteSpace(tokenText[0]); 188=> tokenText.Length > 0 && char.IsWhiteSpace(tokenText[^1]);

Microsoft.CodeAnalysis.CodeStyle.Fixes (2)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeRefactorings\CodeRefactoringHelpers.cs (2)

113while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 116while (start < end && char.IsWhiteSpace(sourceText[start]))

Microsoft.CodeAnalysis.CSharp.Features (3)

BraceCompletion\AbstractCurlyBraceOrBracketCompletionService.cs (3)

77if (!char.IsWhiteSpace(text[i])) 240while (startPoint >= 0 && char.IsWhiteSpace(document.Text[startPoint])) 247while (startPoint >= 0 && !char.IsWhiteSpace(document.Text[startPoint]))

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

Diagnostics\Suppression\SuppressionTests.cs (1)

1151=> line.LastOrNull() is char last && char.IsWhiteSpace(last);

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

DocumentationComments\DocumentationCommentCompilerTests.cs (1)

4405Assert.True(char.IsWhiteSpace(ch));

Microsoft.CodeAnalysis.CSharp.Workspaces (2)

Classification\Worker_DocumentationComments.cs (2)

107if (spanStart != null && char.IsWhiteSpace(ch)) 114else if (spanStart == null && !char.IsWhiteSpace(ch))

Microsoft.CodeAnalysis.EditorFeatures (9)

CommentSelection\AbstractToggleBlockCommentBase.cs (1)

303if (!char.IsWhiteSpace(SnapshotSpan.Snapshot[i]))

IntelliSense\AsyncCompletion\CompletionSource.cs (1)

603while (current < questionPosition && char.IsWhiteSpace(text[current]))

Interactive\InteractivePasteCommandHandler.cs (1)

147if (!char.IsWhiteSpace(snapshot[start + i]))

Interactive\InteractiveWindowResetCommand.cs (2)

103if ((index == 0 || char.IsWhiteSpace(arguments[index - 1])) && 104(index + s_noConfigParameterNameLength == arguments.Length || char.IsWhiteSpace(arguments[index + s_noConfigParameterNameLength])))

SplitComment\SplitCommentCommandHandler.cs (2)

177while (point < line.End && char.IsWhiteSpace(point.GetChar())) 225while (endIndex < position && char.IsWhiteSpace(triviaLine.Snapshot[endIndex]))

StringIndentation\StringIndentationAdornmentManager.VisibleBlock.cs (1)

180!char.IsWhiteSpace(intersectingCharSnapshotPoint.Value.GetChar());

Structure\AbstractStructureTaggerProvider.cs (1)

363while (start < span.End && char.IsWhiteSpace(span.Snapshot[start]))

Microsoft.CodeAnalysis.EditorFeatures.Text (2)

Shared\Extensions\ITextSnapshotLineExtensions.cs (2)

40if (!char.IsWhiteSpace(snapshot[line.Start + i])) 72if (!char.IsWhiteSpace(snapshot[line.Start + i]))

Microsoft.CodeAnalysis.ExpressionEvaluator.FunctionResolver (2)

CSharp\Scanner.cs (1)

89while (_offset < length && char.IsWhiteSpace(_text[_offset]))

VisualBasic\Scanner.cs (1)

84while (_offset < length && char.IsWhiteSpace(_text[_offset]))

Microsoft.CodeAnalysis.Features (5)

Completion\Providers\AbstractDocCommentCompletionProvider.cs (1)

293if (commitChar.HasValue && !char.IsWhiteSpace(commitChar.Value) && commitChar.Value != replacementText[^1])

ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (1)

239while (lookbackLocation > 0 && char.IsWhiteSpace(stringLiteralText[lookbackLocation]))

DocumentationComments\AbstractDocumentationCommentFormattingService.cs (1)

564if (char.IsWhiteSpace(rawText[i]))

DocumentationComments\AbstractDocumentationCommentSnippetService.cs (1)

59if (!char.IsWhiteSpace(text[i]))

Wrapping\AbstractCodeActionComputer.cs (1)

211if (!char.IsWhiteSpace(ch) && ch != '_')

Microsoft.CodeAnalysis.Scripting (3)

Hosting\ObjectFormatter\ObjectFormatterHelpers.cs (3)

420while (j >= start && Char.IsWhiteSpace(str[j])) 458while (i >= start && Char.IsWhiteSpace(str[i])) 466while (i < end && Char.IsWhiteSpace(str[i]))

Microsoft.CodeAnalysis.Test.Utilities (2)

Assert\AssertEx.cs (2)

728=> expected.Where(c => !char.IsWhiteSpace(c)).SequenceEqual(actual.Where(c => !char.IsWhiteSpace(c)));

Microsoft.CodeAnalysis.VisualBasic (1)

Compilation\DocumentationComments\DocumentationCommentCompiler.TextUtils.vb (1)

58While start < [end] And Char.IsWhiteSpace(str(start))

Microsoft.CodeAnalysis.VisualBasic.CodeStyle (1)

src\Workspaces\VisualBasic\Portable\Formatting\Engine\Trivia\VisualBasicTriviaFormatter.vb (1)

44Return Char.IsWhiteSpace(ch) OrElse SyntaxFacts.IsWhitespace(ch)

Microsoft.CodeAnalysis.VisualBasic.Workspaces (3)

Classification\Worker.DocumentationCommentClassifier.vb (2)

87If spanStart IsNot Nothing AndAlso Char.IsWhiteSpace(ch) Then 91ElseIf spanStart Is Nothing AndAlso Not Char.IsWhiteSpace(ch) Then

Formatting\Engine\Trivia\VisualBasicTriviaFormatter.vb (1)

44Return Char.IsWhiteSpace(ch) OrElse SyntaxFacts.IsWhitespace(ch)

Microsoft.CodeAnalysis.Workspaces (13)

Shared\Extensions\SourceTextExtensions.cs (1)

167if (!char.IsWhiteSpace(text[start + i]))

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

127if (!char.IsWhiteSpace(c))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualChar.cs (1)

99=> SurrogateChar != 0 ? char.IsWhiteSpace(SurrogateChar) : Rune.IsWhiteSpace(Rune);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\StringExtensions.cs (2)

20if (!char.IsWhiteSpace(line[i])) 35if (!char.IsWhiteSpace(line[i]))

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

19if (!char.IsWhiteSpace(text[i])) 51if (!char.IsWhiteSpace(text[i])) 71if (!char.IsWhiteSpace(text[i]))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (1)

503if (!char.IsWhiteSpace(this.OriginalString[i]))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (2)

185=> tokenText.Length > 0 && char.IsWhiteSpace(tokenText[0]); 188=> tokenText.Length > 0 && char.IsWhiteSpace(tokenText[^1]);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeRefactorings\CodeRefactoringHelpers.cs (2)

113while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 116while (start < end && char.IsWhiteSpace(sourceText[start]))

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

MSBuild\ProjectFile\CommandLineArgumentReader.cs (2)

29if (string.IsNullOrEmpty(name) || name.Any(char.IsWhiteSpace)) 46if (string.IsNullOrEmpty(value) || (addQuoteIfValueContainsWhitespace && value.Any(char.IsWhiteSpace)))

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

69while (i < commandLine.Length && char.IsWhiteSpace(commandLine[i])) 86while (i < commandLine.Length && (!char.IsWhiteSpace(commandLine[i]) || (quoteCount % 2 != 0)))

Microsoft.Data.Analysis (1)

TextFieldParser.cs (1)

1133if (token.Length == 1 && char.IsWhiteSpace(token[0]))

Microsoft.Data.Analysis.Tests (1)

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

1133if (token.Length == 1 && char.IsWhiteSpace(token[0]))

Microsoft.DotNet.RemoteExecutor (2)

PasteArguments.cs (2)

43if (char.IsWhiteSpace(c)) 144if (char.IsWhiteSpace(c) || c == Quote)

Microsoft.Extensions.Diagnostics.ResourceMonitoring (2)

Linux\LinuxUtilizationParserCgroupV1.cs (1)

383while (numberStart < buffer.Length && char.IsWhiteSpace(buffer[numberStart]))

Linux\LinuxUtilizationParserCgroupV2.cs (1)

573while (numberStart < buffer.Length && char.IsWhiteSpace(buffer[numberStart]))

Microsoft.Extensions.Primitives (2)

StringSegment.cs (2)

598if (!char.IsWhiteSpace(span[i])) 618if (!char.IsWhiteSpace(span[i]))

Microsoft.Maui.Controls (2)

Shapes\PathFigureCollectionConverter.cs (1)

377 if (((ch > ' ') && (ch <= 'z')) || !char.IsWhiteSpace(ch))

StyleSheets\Selector.cs (1)

82 if (char.IsWhiteSpace(c))

Microsoft.Maui.Controls.Xaml (2)

MarkupExpressionParser.cs (1)

228 while (piece.Length > 0 && char.IsWhiteSpace(piece[piece.Length - 1]))

XamlLoader.cs (1)

351 while (char.IsWhiteSpace(firstNonWhitespace))

Microsoft.Maui.Essentials (1)

TextToSpeech\TextToSpeech.shared.cs (1)

102 if (char.IsWhiteSpace(ch) || char.IsPunctuation(ch))

Microsoft.Maui.Graphics.Skia (1)

SkiaTextLayout.cs (1)

233 if (char.IsWhiteSpace(_value[i]))

Microsoft.ML.Core (13)

CommandLine\CmdLexer.cs (3)

84if (char.IsWhiteSpace(ch)) 99if (char.IsWhiteSpace(_curs.ChCur)) 101while (char.IsWhiteSpace(_curs.ChNext()))

Data\ReadOnlyMemoryUtils.cs (6)

183if (!char.IsWhiteSpace(span[ichMin]) && !char.IsWhiteSpace(span[ichLim - 1])) 186while (ichMin < ichLim && char.IsWhiteSpace(span[ichMin])) 188while (ichMin < ichLim && char.IsWhiteSpace(span[ichLim - 1])) 204if (!char.IsWhiteSpace(span[ichLim - 1])) 207while (0 < ichLim && char.IsWhiteSpace(span[ichLim - 1]))

Utilities\DoubleParser.cs (4)

122if (!char.IsWhiteSpace(span[ich])) 152if (!char.IsWhiteSpace(span[ichEnd])) 174if (!char.IsWhiteSpace(span[ich])) 204if (!char.IsWhiteSpace(span[ichEnd]))

Microsoft.ML.Data (2)

DataLoadSave\Text\TextLoaderParser.cs (2)

851if (!char.IsWhiteSpace(span[ichLim - 1])) 854while (0 < ichLim && char.IsWhiteSpace(span[ichLim - 1]))

Microsoft.ML.Predictor.Tests (2)

CmdLine\CmdIndenterTest.cs (1)

68while (ichMin < ichLim && char.IsWhiteSpace(text[ichMin]))

CmdLine\CmdLine.cs (1)

370while (ichMin < ichLim && char.IsWhiteSpace(text[ichMin]))

Microsoft.ML.TestFramework (2)

PasteArguments.cs (2)

89if (char.IsWhiteSpace(c) || c == Quote) 127if (char.IsWhiteSpace(c))

Microsoft.ML.Tests (1)

ExpressionLanguageTests\ExpressionLanguageTests.cs (1)

140while (ichMin < ichLim && char.IsWhiteSpace(text[ichMin]))

Microsoft.ML.Tokenizers.Tests (2)

PreTokenizerTests.cs (2)

90while (index < text.Length && char.IsWhiteSpace(text[index])) 96while (end < text.Length && !char.IsWhiteSpace(text[end]))

Microsoft.ML.TorchSharp (1)

Roberta\QATrainer.cs (1)

460else if (char.IsWhiteSpace(text[i]))

Microsoft.NET.StringTools (2)

SpanBasedStringBuilder.cs (2)

213while (i < span.Length && char.IsWhiteSpace(span[i])) 238while (i >= 0 && char.IsWhiteSpace(span[i]))

Microsoft.VisualStudio.LanguageServices (5)

DebuggerIntelliSense\AbstractDebuggerIntelliSenseContext.cs (1)

244if (!char.IsWhiteSpace(text[i]))

Venus\ContainedDocument.cs (3)

916if (!char.IsWhiteSpace(text[start])) 927if (!char.IsWhiteSpace(text[end])) 1093if (!char.IsWhiteSpace(snapshot[i]))

Venus\ContainedDocument.DocumentServiceProvider.cs (1)

255if (!char.IsWhiteSpace(spanOnPrimarySnapshot.Snapshot[i]))

MSBuild (5)

EscapingUtilities.cs (2)

83while (currentPosition < escapedString.Length && Char.IsWhiteSpace(escapedString[currentPosition])) 91while (Char.IsWhiteSpace(escapedString[escapedStringLength - 1]))

QuotingUtilities.cs (1)

116(((separators.Length == 0) && char.IsWhiteSpace(input[i])) ||

ResourceUtilities.cs (2)

48while (i < message.Length && Char.IsWhiteSpace(message[i])) 118while (i < message.Length && Char.IsWhiteSpace(message[i]))

MSBuildTaskHost (4)

EscapingUtilities.cs (2)

83while (currentPosition < escapedString.Length && Char.IsWhiteSpace(escapedString[currentPosition])) 91while (Char.IsWhiteSpace(escapedString[escapedStringLength - 1]))

ResourceUtilities.cs (2)

48while (i < message.Length && Char.IsWhiteSpace(message[i])) 118while (i < message.Length && Char.IsWhiteSpace(message[i]))

PresentationBuildTasks (18)

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

1077while (!Char.IsWhiteSpace(ch)

src\Microsoft.DotNet.Wpf\src\PresentationCore\System\Windows\Media\ParsersCommon.cs (1)

234if (((ch >' ') && (ch <= 'z')) || ! Char.IsWhiteSpace(ch))

src\Microsoft.DotNet.Wpf\src\PresentationFramework\MS\Internal\Globalization\LocalizationComments.cs (3)

91if (Char.IsWhiteSpace(input[i]) && !escaped) 141else if (!Char.IsWhiteSpace(input[i])) 213if (Char.IsWhiteSpace(input[i]))

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\MarkupExtensionParser.cs (4)

357if (Char.IsWhiteSpace(attrValue[i])) 967if (!nonWhitespaceFound && !Char.IsWhiteSpace(args[i])) 1182Debug.Assert(!Char.IsWhiteSpace(sb[0])); 1185while(Char.IsWhiteSpace(sb[i]))

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\XamlTypeMapper.cs (3)

724if (!Char.IsWhiteSpace(attribValue[i])) 3617(Char.IsWhiteSpace(keyString[0]) || 3618Char.IsWhiteSpace(keyString[keyString.Length-1])))

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\TokenizerHelper.cs (4)

171Debug.Assert(!Char.IsWhiteSpace(currentChar),"Token started on Whitespace"); 212else if ((Char.IsWhiteSpace(currentChar)) || (currentChar == separator)) 258!Char.IsWhiteSpace(currentChar)) 281else if (Char.IsWhiteSpace(currentChar))

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\Xaml\Parser\SpecialBracketCharacters.cs (2)

78else if (char.IsLetterOrDigit(openingBracket) || char.IsLetterOrDigit(closingBracket) || char.IsWhiteSpace(openingBracket) || char.IsWhiteSpace(closingBracket))

PresentationCore (7)

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

460while (i < length && char.IsWhiteSpace(s[i]))

MS\Internal\FontFace\FontFamilyIdentifier.cs (2)

296while (i < length && char.IsWhiteSpace(friendlyName[i])) 328while (end > begin && char.IsWhiteSpace(friendlyName[end - 1]))

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

54if (!Char.IsWhiteSpace(s[i]))

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

234if (((ch >' ') && (ch <= 'z')) || ! Char.IsWhiteSpace(ch))

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

90if (!Char.IsWhiteSpace(c))

System\Windows\TextDecorationCollectionConverter.cs (1)

240for (; index < input.Length && Char.IsWhiteSpace(input[index]); index++) ;

PresentationFramework (26)

MS\Internal\Data\PathParser.cs (3)

105if (char.IsWhiteSpace(c)) 261else if (char.IsWhiteSpace(c)) 309else if (char.IsWhiteSpace(c))

MS\Internal\Globalization\LocalizationComments.cs (3)

91if (Char.IsWhiteSpace(input[i]) && !escaped) 141else if (!Char.IsWhiteSpace(input[i])) 213if (Char.IsWhiteSpace(input[i]))

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\Xaml\Parser\SpecialBracketCharacters.cs (2)

78else if (char.IsLetterOrDigit(openingBracket) || char.IsLetterOrDigit(closingBracket) || char.IsWhiteSpace(openingBracket) || char.IsWhiteSpace(closingBracket))

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

172if (!Char.IsWhiteSpace(s[i]))

System\Windows\Documents\Glyphs.cs (3)

236if (Char.IsWhiteSpace(c)) 369if (!Char.IsWhiteSpace(c)) 400if (!Char.IsWhiteSpace(valueSpec[i]))

System\windows\Documents\TextEditorSpelling.cs (2)

69else if (Char.IsWhiteSpace(character)) 320if (!Char.IsWhiteSpace(character))

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

870if (Char.IsWhiteSpace(separatorChar) ||

System\windows\Documents\TextSelection.cs (2)

489Char.IsWhiteSpace(charBuffer[0])) 502!Char.IsWhiteSpace(charBuffer[0])))

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

1010if (!Char.IsWhiteSpace(value[i]))

System\Windows\Markup\MarkupExtensionParser.cs (4)

357if (Char.IsWhiteSpace(attrValue[i])) 967if (!nonWhitespaceFound && !Char.IsWhiteSpace(args[i])) 1182Debug.Assert(!Char.IsWhiteSpace(sb[0])); 1185while(Char.IsWhiteSpace(sb[i]))

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

37if (!Char.IsWhiteSpace(s[i]))

System\Windows\Markup\XamlTypeMapper.cs (3)

724if (!Char.IsWhiteSpace(attribValue[i])) 3617(Char.IsWhiteSpace(keyString[0]) || 3618Char.IsWhiteSpace(keyString[keyString.Length-1])))

Roslyn.Diagnostics.Analyzers (3)

src\RoslynAnalyzers\Utilities\Refactoring\CodeRefactoringHelpers.cs (2)

32while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 37while (start < end && char.IsWhiteSpace(sourceText[start]))

src\RoslynAnalyzers\Utilities\Refactoring\Extensions\TextLineExtensions.cs (1)

20if (!char.IsWhiteSpace(text[i]))

Roslyn.Diagnostics.CSharp.Analyzers (1)

NumberCommentsRefactoring.cs (1)

117=> new(self.Where(c => !char.IsWhiteSpace(c)).ToArray());

System.CodeDom (2)

src\libraries\Common\src\System\CodeDom\CodeTypeReference.cs (2)

371while (start < typeName.Length && char.IsWhiteSpace(typeName[start])) start++; 372while (end >= 0 && char.IsWhiteSpace(typeName[end])) end--;

System.ComponentModel.Annotations (1)

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

56|| char.IsWhiteSpace(c)

System.Configuration.ConfigurationManager (2)

System\Configuration\GenericEnumConverter.cs (2)

34(!char.IsWhiteSpace(value[0])) && (!char.IsWhiteSpace(value[value.Length - 1])))

System.Data.Common (12)

src\libraries\Common\src\System\Data\Common\DbConnectionOptions.Common.cs (11)

159while ((0 < count) && char.IsWhiteSpace(buffer[count - 1])) 172while ((index < count) && char.IsWhiteSpace(buffer[index])) 176while ((0 < count) && char.IsWhiteSpace(buffer[count - 1])) 221if ((';' == currentChar) || char.IsWhiteSpace(currentChar)) 244if (char.IsWhiteSpace(currentChar)) 261if (char.IsWhiteSpace(currentChar)) 285if (char.IsWhiteSpace(currentChar)) 334if (char.IsWhiteSpace(currentChar)) 345if (char.IsWhiteSpace(currentChar)) 422Debug.Assert(((0 < keyname.Length) && (';' != keyname[0]) && !char.IsWhiteSpace(keyname[0]) && (-1 == keyname.IndexOf('\u0000'))) == compValue, "IsValueValid mismatch with regex"); 425return ((0 < keyname.Length) && (';' != keyname[0]) && !char.IsWhiteSpace(keyname[0]) && (-1 == keyname.IndexOf('\u0000')));

src\libraries\Common\src\System\Data\Common\MultipartIdentifier.cs (1)

61return char.IsWhiteSpace(ch);

System.Data.Odbc (15)

src\libraries\Common\src\System\Data\Common\DbConnectionOptions.Common.cs (11)

src\libraries\Common\src\System\Data\Common\MultipartIdentifier.cs (1)

61return char.IsWhiteSpace(ch);

System\Data\Odbc\OdbcUtils.cs (3)

390while ((_idx < _len) && char.IsWhiteSpace(_sqlstatement[_idx])) 432if (!char.IsWhiteSpace(currentchar)) 534while ((tempidx < _len) && char.IsWhiteSpace(_sqlstatement[tempidx]))

System.Diagnostics.DiagnosticSource (2)

System\Diagnostics\DsesFilterAndTransform.cs (2)

63while (0 < endIdx && char.IsWhiteSpace(filterAndPayloadSpecs[endIdx - 1])) 72while (startIdx < endIdx && char.IsWhiteSpace(filterAndPayloadSpecs[startIdx]))

System.Diagnostics.Process (1)

src\libraries\System.Private.CoreLib\src\System\PasteArguments.cs (1)

86if (char.IsWhiteSpace(c) || c == Quote)

System.Linq.Expressions (1)

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

1198if (char.IsWhiteSpace(c))

System.Net.HttpListener (5)

src\libraries\Common\src\System\Net\CookieParser.cs (1)

198while ((_index < _length) && char.IsWhiteSpace(_tokenStream[_index]))

System\Net\HttpListenerRequest.cs (4)

306if ((chPrev == ';' || chPrev == ',' || char.IsWhiteSpace(chPrev)) && (chNext == '=' || char.IsWhiteSpace(chNext))) 317while (i < l && char.IsWhiteSpace(headerValue[i])) 322while (i < l && char.IsWhiteSpace(headerValue[i]))

System.Net.Primitives (1)

src\libraries\Common\src\System\Net\CookieParser.cs (1)

198while ((_index < _length) && char.IsWhiteSpace(_tokenStream[_index]))

System.Private.CoreLib (21)

src\libraries\System.Private.CoreLib\src\System\Enum.cs (2)

924if (char.IsWhiteSpace(c)) 982if (char.IsWhiteSpace(c))

src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeFormatInfoScanner.cs (2)

300else if (char.IsWhiteSpace(ch)) 461if (_ymdFlags == FoundDatePattern.FoundYMDPatternFlag && !char.IsWhiteSpace(ch))

src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeParse.cs (9)

576while (char.IsWhiteSpace(nextCh) && str.Index + whitespaceCount < str.Length - 1) 1212else if (!char.IsWhiteSpace(ch)) 4475if (parseInfo.fAllowInnerWhite && char.IsWhiteSpace(ch)) 4495if (parseInfo.fAllowTrailingWhite && char.IsWhiteSpace(ch)) 5530else if (char.IsWhiteSpace(m_current)) 5536if (!char.IsWhiteSpace(m_current)) 5801if (!char.IsWhiteSpace(ch)) 5824if (!char.IsWhiteSpace(m_current) && m_current != RightToLeftMark) 5832if (!char.IsWhiteSpace(m_current) && m_current != RightToLeftMark)

src\libraries\System.Private.CoreLib\src\System\Guid.cs (1)

882if (!char.IsWhiteSpace(c))

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.Trim.cs (4)

791(!char.IsWhiteSpace(span[0]) && !char.IsWhiteSpace(span[^1]))) 803if (!char.IsWhiteSpace(span[start])) 812if (!char.IsWhiteSpace(span[end]))

src\libraries\System.Private.CoreLib\src\System\PasteArguments.cs (1)

86if (char.IsWhiteSpace(c) || c == Quote)

src\libraries\System.Private.CoreLib\src\System\String.Manipulation.cs (2)

47Debug.Assert(char.IsWhiteSpace((char)i) == sv.Contains((char)i)); 2330if (Length == 0 || (!char.IsWhiteSpace(_firstChar) && !char.IsWhiteSpace(this[^1])))

System.Private.DataContractSerialization (2)

src\libraries\Common\src\System\CodeDom\CodeTypeReference.cs (2)

371while (start < typeName.Length && char.IsWhiteSpace(typeName[start])) start++; 372while (end >= 0 && char.IsWhiteSpace(typeName[end])) end--;

System.Private.Xml (2)

System\Xml\Schema\XsdDateTime.cs (2)

722while (start < _length && char.IsWhiteSpace(text[start])) 1018while (start < _length && char.IsWhiteSpace(_text[start]))

System.Runtime.Numerics (1)

System\Numerics\Complex.cs (1)

2122if (char.IsWhiteSpace(s[semicolon + 1]))

System.Security.Cryptography (8)

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

101if (char.IsWhiteSpace(s[i])) 115if (char.IsWhiteSpace(c))

System\Security\Cryptography\X509Certificates\X500NameEncoder.cs (6)

229if (char.IsWhiteSpace(c)) 266if (char.IsWhiteSpace(c)) 297if (!char.IsWhiteSpace(c)) 306if (char.IsWhiteSpace(c)) 377if (char.IsWhiteSpace(c)) 402if (!char.IsWhiteSpace(c))

System.Security.Cryptography.Xml (6)

System\Security\Cryptography\Xml\Utils.cs (2)

147if (char.IsWhiteSpace(inputBuffer[inputOffset + i])) iCount++; 151if (!char.IsWhiteSpace(inputBuffer[inputOffset + i]))

System\Security\Cryptography\Xml\XmlDsigBase64Transform.cs (4)

73while ((j < bytesRead) && (!char.IsWhiteSpace((char)buffer[j]))) j++; 77if (!char.IsWhiteSpace((char)buffer[j])) 104while ((j < buffer.Length) && (!char.IsWhiteSpace((char)buffer[j]))) j++; 108if (!char.IsWhiteSpace((char)buffer[j]))

System.Text.Json (2)

System\Text\Json\Serialization\Converters\Value\EnumConverter.cs (2)

568if (string.IsNullOrEmpty(name) || char.IsWhiteSpace(name[0]) || char.IsWhiteSpace(name[name.Length - 1]) ||

System.Text.RegularExpressions (3)

System\Text\RegularExpressions\RegexCharClass.cs (3)

337Debug.Assert(whitespaceSet.Contains((char)i) == char.IsWhiteSpace((char)i)); 1413if (char.IsWhiteSpace(ch)) 1428if (!char.IsWhiteSpace(ch))

System.Text.RegularExpressions.Generator (3)

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexCharClass.cs (3)

337Debug.Assert(whitespaceSet.Contains((char)i) == char.IsWhiteSpace((char)i)); 1413if (char.IsWhiteSpace(ch)) 1428if (!char.IsWhiteSpace(ch))

System.Windows.Forms (3)

System\Windows\Forms\SendKeys\SendKeys.cs (3)

433&& !char.IsWhiteSpace(keys[j])) 447if (char.IsWhiteSpace(keys[j])) 450while (j < keysLen && char.IsWhiteSpace(keys[j]))

System.Windows.Forms.Design (2)

System\ComponentModel\Design\ByteViewer.cs (1)

334if (char.IsLetterOrDigit(c) || char.IsWhiteSpace(c))

System\Windows\Forms\Design\ToolStripDesigner.cs (1)

1768if (char.IsWhiteSpace(c))

System.Windows.Forms.Primitives (3)

System\Windows\Forms\Automation\UiaTextRange.cs (3)

671return (char.IsWhiteSpace(ch1) && !char.IsWhiteSpace(ch2)) 674|| (char.IsPunctuation(ch1) && char.IsWhiteSpace(ch2));

System.Xaml (2)

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\Xaml\Parser\SpecialBracketCharacters.cs (2)

78else if (char.IsLetterOrDigit(openingBracket) || char.IsLetterOrDigit(closingBracket) || char.IsWhiteSpace(openingBracket) || char.IsWhiteSpace(closingBracket))

UIAutomationClientSideProviders (3)

MS\Internal\AutomationProxies\WindowsEditBoxRange.cs (3)

581return (char.IsWhiteSpace(ch1) && !char.IsWhiteSpace(ch2)) 584|| (char.IsPunctuation(ch1) && char.IsWhiteSpace(ch2));

xunit.console (1)

CommandLine.cs (1)

168if (char.IsWhiteSpace(ch))