IsWhiteSpace

510 references to IsWhiteSpace

aspire (1)

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

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

Aspire.Dashboard (4)

Model\EnvHelpers.cs (2)

79char.IsWhiteSpace(value[0]) || 80char.IsWhiteSpace(value[^1]);

Model\TextVisualizerViewModel.cs (1)

243while (index < input.Length && char.IsWhiteSpace(input[index.Value]))

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

DevTunnelCli.cs (1)

321var needsQuotes = a.Any(char.IsWhiteSpace) || a.Contains('"');

Aspire.Hosting.Docker (1)

EnvVarEscaper.cs (1)

216if (!char.IsWhiteSpace(c))

dotnet-dev-certs (1)

RegexGenerator.g.cs (1)

175while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration]))

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)

349while ((index < text.Length) && char.IsWhiteSpace(text[index])) 414if (char.IsWhiteSpace(text[end]))

GenerateDocumentationAndConfigFiles (11)

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

127if (!char.IsWhiteSpace(c))

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\RefactoringHelpers\AbstractRefactoringHelpers.cs (2)

50while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 53while (start < end && char.IsWhiteSpace(sourceText[start]))

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

illink (3)

Linker\Driver.cs (2)

144while (char.IsWhiteSpace((char)cur)) 189if (cur < 0 || (!inquote && char.IsWhiteSpace((char)cur)))

RegexGenerator.g.cs (1)

334while ((uint)iteration1 < (uint)slice.Length && char.IsWhiteSpace(slice[iteration1]))

Metrics (11)

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

127if (!char.IsWhiteSpace(c))

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\RefactoringHelpers\AbstractRefactoringHelpers.cs (2)

50while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 53while (start < end && char.IsWhiteSpace(sourceText[start]))

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

Metrics.Legacy (11)

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

127if (!char.IsWhiteSpace(c))

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\RefactoringHelpers\AbstractRefactoringHelpers.cs (2)

50while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 53while (start < end && char.IsWhiteSpace(sourceText[start]))

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

RegexGenerator.g.cs (1)

175while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration]))

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.AspNetCore.Shared.Tests (1)

RegexGenerator.g.cs (1)

176while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration]))

Microsoft.Build.Framework (2)

Telemetry\CrashTelemetry.cs (2)

527while (start < lineEnd && char.IsWhiteSpace(stackTrace[start])) 553while (end > start && char.IsWhiteSpace(stackTrace[end - 1]))

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

CommandLine\AnalyzerConfig.cs (1)

286if (!char.IsWhiteSpace(c))

CommandLine\CommandLineParser.cs (1)

340if (!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)

266if (!EndOfInput && Char.IsWhiteSpace(Current)) 361if (!EndOfInput && Char.IsWhiteSpace(Current)) 1030if (char.IsWhiteSpace(name[0]))

Microsoft.CodeAnalysis.Analyzers (12)

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer_IdRangeAndCategoryValidation.cs (1)

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

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

127if (!char.IsWhiteSpace(c))

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\RefactoringHelpers\AbstractRefactoringHelpers.cs (2)

50while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 53while (start < end && char.IsWhiteSpace(sourceText[start]))

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.AnalyzerUtilities (11)

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

127if (!char.IsWhiteSpace(c))

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\RefactoringHelpers\AbstractRefactoringHelpers.cs (2)

50while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 53while (start < end && char.IsWhiteSpace(sourceText[start]))

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.BannedApiAnalyzers (11)

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

127if (!char.IsWhiteSpace(c))

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\RefactoringHelpers\AbstractRefactoringHelpers.cs (2)

50while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 53while (start < end && char.IsWhiteSpace(sourceText[start]))

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

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

127if (!char.IsWhiteSpace(c))

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\RefactoringHelpers\AbstractRefactoringHelpers.cs (2)

50while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 53while (start < end && char.IsWhiteSpace(sourceText[start]))

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.CSharp.Features (4)

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]))

Completion\CompletionProviders\FileBasedPrograms\AbstractAppDirectiveCompletionProvider.cs (1)

95if (!char.IsWhiteSpace(span[i]))

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

Diagnostics\Suppression\SuppressionTests.cs (1)

1202=> 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)

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

SplitComment\SplitCommentCommandHandler.cs (2)

175while (point < line.End && char.IsWhiteSpace(point.GetChar())) 223while (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 (10)

Completion\Providers\AbstractDocCommentCompletionProvider.cs (1)

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

ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (1)

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

DocumentationComments\AbstractDocumentationCommentFormattingService.cs (1)

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

DocumentationComments\AbstractDocumentationCommentSnippetService.cs (1)

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

DocumentationComments\DocumentationCommentSnippetHelpers.cs (1)

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

EmbeddedLanguages\Json\JsonLexer.cs (2)

183_ => char.IsWhiteSpace(ch), 336while (Position < Text.Length && char.IsWhiteSpace(this.CurrentChar))

StackTraceExplorer\StackTraceAnalyzer.cs (2)

102while (char.IsWhiteSpace(virtualChars[start]) && start < end) 107while (char.IsWhiteSpace(virtualChars[end]) && end > start)

Wrapping\AbstractCodeActionComputer.cs (1)

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

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (11)

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

127if (!char.IsWhiteSpace(c))

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\RefactoringHelpers\AbstractRefactoringHelpers.cs (2)

50while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 53while (start < end && char.IsWhiteSpace(sourceText[start]))

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.PublicApiAnalyzers (11)

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

127if (!char.IsWhiteSpace(c))

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\RefactoringHelpers\AbstractRefactoringHelpers.cs (2)

50while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 53while (start < end && char.IsWhiteSpace(sourceText[start]))

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.ResxSourceGenerator (11)

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

127if (!char.IsWhiteSpace(c))

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\RefactoringHelpers\AbstractRefactoringHelpers.cs (2)

50while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 53while (start < end && char.IsWhiteSpace(sourceText[start]))

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

Hosting\ObjectFormatter\ObjectFormatterHelpers.cs (3)

419while (j >= start && Char.IsWhiteSpace(str[j])) 457while (i >= start && Char.IsWhiteSpace(str[i])) 465while (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.Workspaces (12)

Shared\Extensions\SourceTextExtensions.cs (1)

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

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

127if (!char.IsWhiteSpace(c))

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\RefactoringHelpers\AbstractRefactoringHelpers.cs (2)

50while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 53while (start < end && char.IsWhiteSpace(sourceText[start]))

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.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.AI.Evaluation.NLP (1)

Common\SimpleWordTokenizer.cs (1)

64if (char.IsWhiteSpace(nextChar))

Microsoft.Extensions.Diagnostics.ResourceMonitoring (2)

Linux\LinuxUtilizationParserCgroupV1.cs (1)

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

Linux\LinuxUtilizationParserCgroupV2.cs (1)

614while (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 (15)

RegexGenerator.g.cs (15)

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)

272while (i < span.Length && char.IsWhiteSpace(span[i])) 319while (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]))

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

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

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])))

RepoTasks (1)

RegexGenerator.g.cs (1)

175while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration]))

Roslyn.Diagnostics.Analyzers (11)

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

127if (!char.IsWhiteSpace(c))

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\RefactoringHelpers\AbstractRefactoringHelpers.cs (2)

50while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 53while (start < end && char.IsWhiteSpace(sourceText[start]))

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

Roslyn.Diagnostics.CSharp.Analyzers (1)

NumberCommentsRefactoring.cs (1)

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

System.CodeDom (2)

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

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

System.ComponentModel.Annotations (1)

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

56|| char.IsWhiteSpace(c)

System.ComponentModel.TypeConverter (1)

RegexGenerator.g.cs (1)

334while ((uint)iteration1 < (uint)slice.Length && char.IsWhiteSpace(slice[iteration1]))

System.Configuration.ConfigurationManager (2)

System\Configuration\GenericEnumConverter.cs (2)

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

System.Data.Common (13)

RegexGenerator.g.cs (1)

334while ((uint)iteration1 < (uint)slice.Length && char.IsWhiteSpace(slice[iteration1]))

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

152while ((0 < count) && char.IsWhiteSpace(buffer[count - 1])) 165while ((index < count) && char.IsWhiteSpace(buffer[index])) 169while ((0 < count) && char.IsWhiteSpace(buffer[count - 1])) 214if ((';' == currentChar) || char.IsWhiteSpace(currentChar)) 237if (char.IsWhiteSpace(currentChar)) 254if (char.IsWhiteSpace(currentChar)) 278if (char.IsWhiteSpace(currentChar)) 327if (char.IsWhiteSpace(currentChar)) 338if (char.IsWhiteSpace(currentChar)) 414Debug.Assert(((0 < keyname.Length) && (';' != keyname[0]) && !char.IsWhiteSpace(keyname[0]) && !keyname.Contains('\u0000')) == compValue, "IsValueValid mismatch with regex"); 416return ((0 < keyname.Length) && (';' != keyname[0]) && !char.IsWhiteSpace(keyname[0]) && !keyname.Contains('\u0000'));

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

61return char.IsWhiteSpace(ch);

System.Data.Odbc (27)

RegexGenerator.g.cs (12)

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

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

297if (!char.IsWhiteSpace(value[start]) && value[start] != '\0') 307if (!char.IsWhiteSpace(value[end]) && value[end] != '\0')

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

948return IsWhiteSpace(s[index]);

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\Environment.GetFolderPathCore.Unix.cs (1)

253while (pos < line.Length && char.IsWhiteSpace(line[pos])) pos++;

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

2433if (char.IsWhiteSpace(str[0]) || char.IsWhiteSpace(str[^1]))

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

290else if (char.IsWhiteSpace(ch)) 451if (_ymdFlags == FoundDatePattern.FoundYMDPatternFlag && !char.IsWhiteSpace(ch)) 593if (char.IsWhiteSpace(array[i][j]))

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

586while (char.IsWhiteSpace(nextCh) && str.Index + whitespaceCount < str.Length - 1) 1218else if (!char.IsWhiteSpace(ch)) 4467if (parseInfo.fAllowInnerWhite && char.IsWhiteSpace(quotedSpan[i])) 4541if (parseInfo.fAllowInnerWhite && char.IsWhiteSpace(ch)) 4561if (parseInfo.fAllowTrailingWhite && char.IsWhiteSpace(ch)) 5631else if (char.IsWhiteSpace(m_current)) 5637if (!char.IsWhiteSpace(m_current)) 5717if (!char.IsWhiteSpace(Value[thisPosition + segmentLength])) 5732while (thisPosition < Value.Length && char.IsWhiteSpace(Value[thisPosition])) 5902if (!char.IsWhiteSpace(ch)) 5925if (!char.IsWhiteSpace(m_current) && m_current != RightToLeftMark) 5933if (!char.IsWhiteSpace(m_current) && m_current != RightToLeftMark) 5945while (i >= 0 && char.IsWhiteSpace(Value[i])) 5965if (char.IsWhiteSpace(Value[i - 1])) 5968while (i >= 1 && char.IsWhiteSpace(Value[i - 1])) 5993while ((i + 1) < Length && char.IsWhiteSpace(Value[i + 1]))

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

904for (i = 0; i < charSpan.Length && !char.IsWhiteSpace(charSpan[i]); i++) ; 923if (!char.IsWhiteSpace(c))

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

5398while (startInclusive < endExclusive && char.IsWhiteSpace(source[startInclusive])) 5403while (endExclusive > startInclusive && char.IsWhiteSpace(source[endExclusive - 1]))

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.Globalization.cs (1)

21if (!char.IsWhiteSpace(span[i]))

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

574(!char.IsWhiteSpace(span[0]) && !char.IsWhiteSpace(span[^1]))) 586if (!char.IsWhiteSpace(span[start])) 595if (!char.IsWhiteSpace(span[end])) 613if (!char.IsWhiteSpace(span[start])) 631if (!char.IsWhiteSpace(span[end])) 791(!char.IsWhiteSpace(span[0]) && !char.IsWhiteSpace(span[^1]))) 803if (!char.IsWhiteSpace(span[start])) 812if (!char.IsWhiteSpace(span[end])) 845if (!char.IsWhiteSpace(span[start])) 868if (!char.IsWhiteSpace(span[end]))

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

208for (; localIndex < s.Length && char.IsWhiteSpace(s[localIndex]); localIndex++) ;

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

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

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

514if (!char.IsWhiteSpace(value[i])) return false;

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

47Debug.Assert(char.IsWhiteSpace((char)i) == sv.Contains((char)i)); 2040if (char.IsWhiteSpace(source[i])) 2387if (Length == 0 || (!char.IsWhiteSpace(_firstChar) && !char.IsWhiteSpace(this[^1]))) 2644if (!char.IsWhiteSpace(this[start])) 2655if (!char.IsWhiteSpace(this[end]))

System.Private.DataContractSerialization (3)

RegexGenerator.g.cs (1)

334while ((uint)iteration1 < (uint)slice.Length && char.IsWhiteSpace(slice[iteration1]))

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

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

System.Private.Xml (3)

RegexGenerator.g.cs (1)

334while ((uint)iteration1 < (uint)slice.Length && char.IsWhiteSpace(slice[iteration1]))

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

750while (start < _length && char.IsWhiteSpace(text[start])) 1054while (start < _length && char.IsWhiteSpace(_text[start]))

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

RegexGenerator.g.cs (1)

334while ((uint)iteration1 < (uint)slice.Length && char.IsWhiteSpace(slice[iteration1]))

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

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

System.Text.RegularExpressions (3)

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

207Debug.Assert(whitespaceSet.Contains((char)i) == char.IsWhiteSpace((char)i)); 1366if (char.IsWhiteSpace(ch)) 1381if (!char.IsWhiteSpace(ch))

System.Text.RegularExpressions.Generator (3)

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

207Debug.Assert(whitespaceSet.Contains((char)i) == char.IsWhiteSpace((char)i)); 1366if (char.IsWhiteSpace(ch)) 1381if (!char.IsWhiteSpace(ch))

System.Windows.Forms (4)

RegexGenerator.g.cs (1)

116while ((uint)iteration < (uint)slice.Length && !char.IsWhiteSpace(slice[iteration]))

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

RegexGenerator.g.cs (1)

116while ((uint)iteration < (uint)slice.Length && !char.IsWhiteSpace(slice[iteration]))

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

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

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

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

Templates.Blazor.Tests (1)

RegexGenerator.g.cs (1)

175while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration]))

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

RegexGenerator.g.cs (1)

175while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration]))

Templates.Blazor.WebAssembly.Tests (1)

RegexGenerator.g.cs (1)

175while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration]))

Templates.Mvc.Tests (1)

RegexGenerator.g.cs (1)

175while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration]))

Templates.Tests (1)

RegexGenerator.g.cs (1)

175while ((uint)iteration < (uint)slice.Length && char.IsWhiteSpace(slice[iteration]))

Test.Utilities (11)

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

127if (!char.IsWhiteSpace(c))

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\RefactoringHelpers\AbstractRefactoringHelpers.cs (2)

50while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 53while (start < end && char.IsWhiteSpace(sourceText[start]))

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

Text.Analyzers (11)

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

127if (!char.IsWhiteSpace(c))

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\RefactoringHelpers\AbstractRefactoringHelpers.cs (2)

50while (start < end && char.IsWhiteSpace(sourceText[end - 1])) 53while (start < end && char.IsWhiteSpace(sourceText[start]))

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

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