StringSplitOptions

648 references to StringSplitOptions

Analyzer.Utilities.UnitTests (1)

Options\SymbolNamesWithValueOptionTests.cs (1)

260var split = symbolName.Split(new[] { "->" }, StringSplitOptions.RemoveEmptyEntries);

Aspire.Dashboard (14)

Components\Dialogs\TextVisualizerDialog.razor.cs (1)

129var lines = FormattedText.Split(["\r\n", "\r", "\n"], StringSplitOptions.None).ToList();

Configuration\DashboardOptions.cs (6)

189var parts = EndpointUrls.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries); 291_nameClaimTypes = NameClaimType.Split(",", StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries); 301_usernameClaimTypes = UsernameClaimType.Split(",", StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);

DashboardWebApplication.cs (4)

216builder.WithOrigins(corsOptions.AllowedOrigins.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)); 223? corsOptions.AllowedHeaders.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)

Model\BrowserLinkOutgoingPeerResolver.cs (1)

44var parts = uri.AbsolutePath.Split('/', StringSplitOptions.RemoveEmptyEntries);

src\Shared\IConfigurationExtensions.cs (2)

151.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)

Aspire.Dashboard.Components.Tests (2)

tests\Shared\Logging\XunitLoggerProvider.cs (2)

75var lines = formatter(state, exception).Split(s_newLineChars, StringSplitOptions.RemoveEmptyEntries); 86lines = exception.ToString().Split(s_newLineChars, StringSplitOptions.RemoveEmptyEntries);

Aspire.Dashboard.Tests (2)

tests\Shared\Logging\XunitLoggerProvider.cs (2)

Aspire.Hosting (4)

ApplicationModel\ContainerFileSystemCallbackAnnotation.cs (1)

129var parts = relativePath.Split([Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar], StringSplitOptions.RemoveEmptyEntries);

ProjectResourceBuilderExtensions.cs (1)

431var urlsFromApplicationUrl = launchProfile.ApplicationUrl?.Split(';', StringSplitOptions.RemoveEmptyEntries) ?? [];

src\Shared\IConfigurationExtensions.cs (2)

151.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)

Aspire.Hosting.Testing.Tests (2)

tests\Shared\Logging\XunitLoggerProvider.cs (2)

Aspire.Hosting.Tests (2)

tests\Shared\Logging\XunitLoggerProvider.cs (2)

Aspire.Playground.Tests (2)

tests\Shared\Logging\XunitLoggerProvider.cs (2)

BuildBoss (1)

ProjectUtil.cs (1)

73var all = targetFrameworks.Value.ToString().Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);

ClientSample (1)

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (1)

18foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries))

CodeStyleConfigFileGenerator (1)

Program.cs (1)

40var assemblyList = args[3].Split([';'], StringSplitOptions.RemoveEmptyEntries).ToImmutableArray();

ConfigurationSchemaGenerator (2)

ConfigSchemaEmitter.cs (2)

480var lines = text.Split(s_lineBreaks, StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);

Crossgen2Tasks (1)

RunReadyToRunCompiler.cs (1)

349foreach (string extraArg in Crossgen2ExtraCommandLineArgs.Split(';', StringSplitOptions.RemoveEmptyEntries))

csc (1)

src\Compilers\Shared\RuntimeHostInfo.cs (1)

59foreach (var item in path.Split(sep, StringSplitOptions.RemoveEmptyEntries))

CSharpSyntaxGenerator (2)

SourceWriter.cs (2)

1796var lines = comment.Split(new string[] { "\r", "\n", "\r\n" }, StringSplitOptions.RemoveEmptyEntries); 1814string[] lines = element.OuterXml.Split(new string[] { "\r", "\n", "\r\n" }, StringSplitOptions.RemoveEmptyEntries);

dotnet-dev-certs (1)

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (1)

18foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries))

dotnet-getdocument (2)

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (1)

18foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries))

src\Tools\GetDocumentInsider\src\ReporterExtensions.cs (1)

33.Split(new[] { Environment.NewLine }, StringSplitOptions.None)

dotnet-openapi (2)

Internal\OpenapiDependencyAttribute.cs (1)

18CodeGenerators = codeGenerators.Split(';', StringSplitOptions.RemoveEmptyEntries).Select(Enum.Parse<CodeGenerator>).ToArray();

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (1)

18foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries))

dotnet-sql-cache (1)

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (1)

18foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries))

dotnet-svcutil-lib (9)

FrameworkFork\Microsoft.Xml\Xml\XmlConvert.cs (2)

1594return value.Split(WhitespaceChars, StringSplitOptions.RemoveEmptyEntries); 1597internal static string[] SplitString(string value, StringSplitOptions splitStringOptions)

FrameworkFork\System.ServiceModel\System\IdentityModel\Claims\X509CertificateClaimSet.cs (1)

317asnString.Split(new string[1] { X509SubjectAlternativeNameConstants.Separator }, StringSplitOptions.RemoveEmptyEntries);

FrameworkFork\System.ServiceModel\System\ServiceModel\Description\WsdlImporter.cs (1)

2152return attribute.Value.Split((char[])null, StringSplitOptions.RemoveEmptyEntries);

Shared\MSBuildProj.cs (1)

215foreach (var targetFx in targetFrameworks.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries).Select(p => p.Trim()))

Shared\Utilities\PathHelper.cs (3)

114var parentSegments = Path.GetFullPath(parentPath.FullName).Split(new char[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries); 115var childSegments = Path.GetFullPath(childDirectory).Split(new char[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries); 168return path.Split(new char[] { '/', '\\', Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries);

Tool.cs (1)

46.InformationalVersion.Split(new char[] { '@' }, StringSplitOptions.RemoveEmptyEntries)[0].Trim();

dotnet-user-jwts (1)

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (1)

18foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries))

dotnet-user-secrets (1)

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (1)

18foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries))

GenerateAnalyzerNuspec (6)

Program.cs (6)

24var metadataList = args[5].Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); 25var fileList = args[6].Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); 27var folderList = args[8].Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); 28var assemblyList = args[9].Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); 29var dependencyList = args[10].Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); 30var libraryList = args[11].Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);

GenerateDocumentationAndConfigFiles (9)

Program.cs (1)

215var assemblyList = assembliesString.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).ToList();

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

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

347var split = name.Split(new[] { "->" }, StringSplitOptions.RemoveEmptyEntries); 396var split = name.Split(new[] { "->" }, StringSplitOptions.RemoveEmptyEntries); 491var names = optionValue.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

58foreach (var platform in itemOptionValue.Split(s_itemMetadataValuesSeparators, StringSplitOptions.RemoveEmptyEntries))

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

395words = name.Split([WordSeparator], StringSplitOptions.RemoveEmptyEntries);

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

72var parts = @namespace.Split(NamespaceSeparatorArray, options: StringSplitOptions.RemoveEmptyEntries);

GetDocument.Insider (2)

ReporterExtensions.cs (1)

33.Split(new[] { Environment.NewLine }, StringSplitOptions.None)

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (1)

18foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries))

HostFilteringSample (1)

Startup.cs (1)

31var hosts = Config["AllowedHosts"]?.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);

illink (2)

Linker.Steps\DescriptorMarker.cs (1)

304_accessorsSep, StringSplitOptions.RemoveEmptyEntries);

Linker\Driver.cs (1)

976string[] values = value.Split(s_separators, StringSplitOptions.RemoveEmptyEntries);

ILLink.Tasks (5)

CreateRuntimeRootDescriptorFile.cs (5)

164string[] namespaceDefElements = namespaceDef.Split(separators, StringSplitOptions.RemoveEmptyEntries); 207string[] featureSwitchElements = def.Split(separators, StringSplitOptions.RemoveEmptyEntries); 236defElements = def.Split(separators, StringSplitOptions.RemoveEmptyEntries); 305string[] defElements = def.Split(separators, StringSplitOptions.RemoveEmptyEntries); 328string[] defElements = def.Split(separators, StringSplitOptions.RemoveEmptyEntries);

Infrastructure.Common (1)

xunit\IssueAttribute.cs (1)

116string[] issues = includeTestsWithIssues.Split(new char[] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries);

installer.tasks (4)

GenerateRunScript.cs (4)

70string[] setCommandsSplit = SetCommands[i].Split(newlineSeparator, StringSplitOptions.None); 85string[] runCommandsSplit = RunCommands[i].Split(newlineSeparator, StringSplitOptions.None); 101foreach (string setCommandOneLine in setCommand.Split(newlineSeparator, StringSplitOptions.None)) 111foreach (string runCommandOneLine in runCommand.Split(newlineSeparator, StringSplitOptions.None))

InteractiveHost.UnitTests (1)

AbstractInteractiveHostTests.cs (1)

129return ImmutableArray.Create(text.Split(["\r\n"], StringSplitOptions.RemoveEmptyEntries));

IOperationGenerator (2)

IOperationClassWriter.cs (2)

247string[] lines = el.InnerXml.Split(separators, StringSplitOptions.RemoveEmptyEntries); 1120private static List<string> GetPropertyOrder(Node node) => node.ChildrenOrder?.Split(",", StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).ToList() ?? new List<string>();

Metrics (9)

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

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

173foreach (var line in child.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries))

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

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

58foreach (var platform in itemOptionValue.Split(s_itemMetadataValuesSeparators, StringSplitOptions.RemoveEmptyEntries))

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

395words = name.Split([WordSeparator], StringSplitOptions.RemoveEmptyEntries);

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

72var parts = @namespace.Split(NamespaceSeparatorArray, options: StringSplitOptions.RemoveEmptyEntries);

Metrics.Legacy (9)

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

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

173foreach (var line in child.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries))

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

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

58foreach (var platform in itemOptionValue.Split(s_itemMetadataValuesSeparators, StringSplitOptions.RemoveEmptyEntries))

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

395words = name.Split([WordSeparator], StringSplitOptions.RemoveEmptyEntries);

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

72var parts = @namespace.Split(NamespaceSeparatorArray, options: StringSplitOptions.RemoveEmptyEntries);

Microsoft.Arcade.Test.Common (2)

AssertEx.cs (1)

489str.Trim().Replace("\r\n", "\n").Split(new[] { '\r', '\n' }, StringSplitOptions.None);

DiffUtil.cs (1)

89return s.Split(s_lineSplitChars, StringSplitOptions.RemoveEmptyEntries);

Microsoft.AspNetCore (1)

WebHost.cs (1)

259var hosts = hostingContext.Configuration["AllowedHosts"]?.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);

Microsoft.AspNetCore.Analyzer.Testing (1)

TestSource.cs (1)

24var lines = rawSource.Split(new[] { "\n", "\r\n" }, StringSplitOptions.None);

Microsoft.AspNetCore.App.CodeFixes (1)

RouteParameterUnusedParameterFixer.cs (1)

132foreach (var policy in routeParameterPolicy.Split(new[] { ':' }, StringSplitOptions.RemoveEmptyEntries))

Microsoft.AspNetCore.App.UnitTests (9)

SharedFxTests.cs (4)

65.Split(';', StringSplitOptions.RemoveEmptyEntries) 165.Split(';', StringSplitOptions.RemoveEmptyEntries) 219.Split(';', StringSplitOptions.RemoveEmptyEntries) 262.Split(';', StringSplitOptions.RemoveEmptyEntries)

TargetingPackTests.cs (5)

65.Split(';', StringSplitOptions.RemoveEmptyEntries) 141.Split(';', StringSplitOptions.RemoveEmptyEntries) 144.Split(';', StringSplitOptions.RemoveEmptyEntries) 229.Split(';', StringSplitOptions.RemoveEmptyEntries) 294.Split(';', StringSplitOptions.RemoveEmptyEntries)

Microsoft.AspNetCore.Components (1)

src\Http\Routing\src\ParameterPolicyActivator.cs (1)

112var arguments = argumentString?.Split(',', StringSplitOptions.TrimEntries) ?? Array.Empty<string>();

Microsoft.AspNetCore.Components.WebAssembly (1)

.packages\microsoft.dotnet.hotreload.agent\10.0.100-preview.7.25351.105\contentFiles\cs\netstandard2.1\HotReloadAgent.cs (1)

236var updatedValues = environment.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries)

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

DebugProxyLauncher.cs (1)

46var noProxyEnvVarValues = noProxyEnvVar.Split(",", StringSplitOptions.TrimEntries);

Microsoft.AspNetCore.Components.WebView (2)

src\Shared\StaticWebAssets\ManifestStaticWebAssetFileProvider.cs (2)

44var segments = Normalize(subpath).Split('/', StringSplitOptions.RemoveEmptyEntries); 158var segments = subpath.Split('/', StringSplitOptions.RemoveEmptyEntries);

Microsoft.AspNetCore.Diagnostics (5)

DeveloperExceptionPage\DeveloperExceptionPageMiddlewareImpl.cs (1)

306.Split(new[] { Environment.NewLine }, StringSplitOptions.None);

src\Shared\Diagnostics\BaseView.cs (2)

294input.Split(new[] { "\r\n" }, StringSplitOptions.None) 295.SelectMany(s => s.Split(new[] { '\r', '\n' }, StringSplitOptions.None))

src\Shared\RazorViews\BaseView.cs (2)

284input.Split("\r\n", StringSplitOptions.None) 285.SelectMany(s => s.Split(NewLineChars, StringSplitOptions.None))

Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore (4)

src\Shared\Diagnostics\BaseView.cs (2)

294input.Split(new[] { "\r\n" }, StringSplitOptions.None) 295.SelectMany(s => s.Split(new[] { '\r', '\n' }, StringSplitOptions.None))

src\Shared\RazorViews\BaseView.cs (2)

284input.Split("\r\n", StringSplitOptions.None) 285.SelectMany(s => s.Split(NewLineChars, StringSplitOptions.None))

Microsoft.AspNetCore.Grpc.JsonTranscoding (2)

Internal\Json\FieldMaskConverter.cs (1)

30var jsonPaths = reader.GetString()!.Split(',', StringSplitOptions.RemoveEmptyEntries);

src\Grpc\JsonTranscoding\src\Shared\X509CertificateHelpers.cs (1)

51asnString.Split(new string[1] { X509SubjectAlternativeNameConstants.Separator }, StringSplitOptions.RemoveEmptyEntries);

Microsoft.AspNetCore.HostFiltering.Tests (3)

HostFilteringMiddlewareTests.cs (2)

148options.AllowedHosts = allowedHost.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); 200options.AllowedHosts = allowedHost.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);

MiddlewareConfigurationManagerTests.cs (1)

46AllowedHosts = allowedHost.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries),

Microsoft.AspNetCore.Hosting (10)

GenericHost\GenericWebHostService.cs (3)

87ports.Split(';', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries) 115foreach (var value in urls.Split(';', StringSplitOptions.RemoveEmptyEntries))

Internal\WebHost.cs (1)

270foreach (var value in urls.Split(';', StringSplitOptions.RemoveEmptyEntries))

Internal\WebHostOptions.cs (2)

79return value?.Split(';', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries)

src\Shared\RazorViews\BaseView.cs (2)

284input.Split("\r\n", StringSplitOptions.None) 285.SelectMany(s => s.Split(NewLineChars, StringSplitOptions.None))

src\Shared\StaticWebAssets\ManifestStaticWebAssetFileProvider.cs (2)

44var segments = Normalize(subpath).Split('/', StringSplitOptions.RemoveEmptyEntries); 158var segments = subpath.Split('/', StringSplitOptions.RemoveEmptyEntries);

Microsoft.AspNetCore.HttpOverrides.Tests (3)

ForwardedHeadersMiddlewareTest.cs (3)

497AllowedHosts = allowedHost.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries) 1085foreach (var knownProxy in knownProxies.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries)) 1090foreach (var knownNetwork in knownNetworks.Split(new string[] { "," }, options: StringSplitOptions.RemoveEmptyEntries))

Microsoft.AspNetCore.InternalTesting (3)

Logging\XunitLoggerProvider.cs (2)

77var lines = formatter(state, exception).Split(NewLineChars, StringSplitOptions.RemoveEmptyEntries); 88lines = exception.ToString().Split(NewLineChars, StringSplitOptions.RemoveEmptyEntries);

xunit\SkipOnHelixAttribute.cs (1)

71return Queues.ToLowerInvariant().Split([';'], StringSplitOptions.RemoveEmptyEntries)

Microsoft.AspNetCore.InternalTesting.Tests (1)

AssemblyTestLogTests.cs (1)

392return string.Join(Environment.NewLine, input.Split(new[] { Environment.NewLine }, StringSplitOptions.None)

Microsoft.AspNetCore.Localization (1)

CookieRequestCultureProvider.cs (1)

74if (valueSpan.Split(parts, _cookieSeparator, StringSplitOptions.RemoveEmptyEntries) != 2)

Microsoft.AspNetCore.Localization.Tests (1)

CustomRequestCultureProviderTest.cs (1)

67var segments = context.Request.Path.Value.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);

Microsoft.AspNetCore.Mvc.Core (2)

BindAttribute.cs (2)

79=> original?.Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries) ?? Array.Empty<string>();

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

ApplicationModels\ControllerActionDescriptorProviderTests.cs (2)

1402.Split(new[] { Environment.NewLine }, StringSplitOptions.None) 1406.Split(new[] { Environment.NewLine }, StringSplitOptions.None)

Microsoft.AspNetCore.Mvc.TagHelpers (4)

TagHelperOutputExtensions.cs (4)

171var arrayOfClasses = currentClassValue.Split(SpaceChars, StringSplitOptions.RemoveEmptyEntries) 172.SelectMany(perhapsEncoded => perhapsEncoded.Split(encodedSpaceChars, StringSplitOptions.RemoveEmptyEntries)) 235var listOfClasses = currentClassValue.Split(SpaceChars, StringSplitOptions.RemoveEmptyEntries) 236.SelectMany(perhapsEncoded => perhapsEncoded.Split(encodedSpaceChars, StringSplitOptions.RemoveEmptyEntries))

Microsoft.AspNetCore.Mvc.ViewFeatures (2)

RemoteAttributeBase.cs (2)

171=> original?.Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries) ?? Array.Empty<string>();

Microsoft.AspNetCore.Routing (1)

ParameterPolicyActivator.cs (1)

112var arguments = argumentString?.Split(',', StringSplitOptions.TrimEntries) ?? Array.Empty<string>();

Microsoft.AspNetCore.Routing.Tests (2)

Template\TemplateBinderTests.cs (2)

1455.Split(new char[] { '&' }, StringSplitOptions.None) 1456.Select(s => s.Split(new char[] { '=' }, StringSplitOptions.None))

Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (4)

AuthenticationTests.cs (4)

202var authTypeList = authType.ToString().Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 249var authTypeList = authType.ToString().Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 272var authTypeList = authType.ToString().Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 316var authTypeList = authType.ToString().Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);

Microsoft.AspNetCore.Server.IIS (3)

src\Shared\RazorViews\BaseView.cs (2)

284input.Split("\r\n", StringSplitOptions.None) 285.SelectMany(s => s.Split(NewLineChars, StringSplitOptions.None))

WebHostBuilderIISExtensions.cs (1)

52options.ServerAddresses = iisConfigData.pwzBindings.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);

Microsoft.AspNetCore.Server.IISIntegration (1)

WebHostBuilderIISExtensions.cs (1)

68foreach (var authType in iisAuth.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries))

Microsoft.AspNetCore.Shared.Tests (1)

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (1)

18foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries))

Microsoft.AspNetCore.SignalR.Tests.Utils (1)

src\Shared\SignalR\InProcessTestServer.cs (1)

148foreach (var line in message.Split(new[] { Environment.NewLine }, StringSplitOptions.None))

Microsoft.AspNetCore.StaticFiles (1)

HtmlDirectoryFormatter.cs (1)

106foreach (var segment in requestPath.Value!.Split('/', StringSplitOptions.RemoveEmptyEntries))

Microsoft.Build (29)

BackEnd\Components\RequestBuilder\IntrinsicTasks\MSBuild.cs (6)

258undefinePropertiesArray = RemoveProperties.Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries); 460string[] expandedPropertyValues = p.Split(TargetAndPropertyListSeparators, StringSplitOptions.RemoveEmptyEntries); 477string[] expandedTargetValues = t.Split(TargetAndPropertyListSeparators, StringSplitOptions.RemoveEmptyEntries); 562projects[i].GetMetadata(ItemMetadataNames.PropertiesMetadataName).Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries), 581string[] propertiesToUndefine = projectUndefineProperties.Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries); 606projects[i].GetMetadata(ItemMetadataNames.AdditionalPropertiesMetadataName).Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries),

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

1528.SelectMany(w => w.Split([','], StringSplitOptions.RemoveEmptyEntries))

BackEnd\Node\OutOfProcNode.cs (1)

819propertyListToSerialize = forwardPropertiesFromChild.Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries);

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

72var lines = string.IsNullOrEmpty(text) ? [] : text.Split(["\r\n", "\n"], StringSplitOptions.None);

CanonicalError.cs (1)

373string[] explodedText = parsedMessage.text.Split(MSBuildConstants.SingleQuoteChar, StringSplitOptions.RemoveEmptyEntries);

Construction\Solution\SolutionFile.cs (2)

979string[] words = str.Split(delimiterChars, StringSplitOptions.RemoveEmptyEntries); 1437string[] projectReferenceEntries = propertyValue.Split([';'], StringSplitOptions.RemoveEmptyEntries);

Construction\Solution\SolutionProjectGenerator.cs (1)

192_targetNames = targetNames.Select(i => i.Split([':'], 2, StringSplitOptions.RemoveEmptyEntries).Last()).ToList();

Definition\Project.cs (1)

3457string[] existingIncludePieces = evaluatedExistingInclude.Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries);

Definition\ToolsetConfigurationReader.cs (1)

246.Split(s_separatorForExtensionsPathSearchPaths, StringSplitOptions.RemoveEmptyEntries)

Evaluation\Evaluator.cs (1)

970List<string> temp = new List<string>(expanded.Split(s_splitter, StringSplitOptions.RemoveEmptyEntries));

EventArgsFormatting.cs (1)

375string[] subStrings = s.Split(s_newLines, StringSplitOptions.None);

FileUtilities.cs (3)

416var segments = path.Split(Slashes, StringSplitOptions.RemoveEmptyEntries); 1174string[] splitBase = fullBase.Split(MSBuildConstants.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries); 1175string[] splitPath = fullPath.Split(MSBuildConstants.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries);

Graph\ProjectInterpretation.cs (2)

433propertyNameAndValuesString.Split(PropertySeparator, StringSplitOptions.RemoveEmptyEntries), 454return propertyNamesString.Split(PropertySeparator, StringSplitOptions.RemoveEmptyEntries);

Logging\BaseConsoleLogger.cs (1)

134string[] subStrings = s.Split(newLines, StringSplitOptions.None);

Logging\BinaryLogger\BinaryLogger.cs (1)

433var parameters = Parameters.Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries);

Logging\TerminalLogger\TerminalLogger.cs (1)

1291string[] lines = message.Split(newLineStrings, StringSplitOptions.None);

PlatformNegotiation.cs (2)

37foreach (string s in projectReferencePlatformsMetadata.Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries)) 108foreach (string s in stringTable.Trim().Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries))

Utilities\NuGetFrameworkWrapper.cs (1)

147return desiredTargetFrameworks.Split([';'], StringSplitOptions.RemoveEmptyEntries).Select(tfm =>

Utilities\RegistryKeyWrapper.cs (1)

166string[] keyNames = name.Split(MSBuildConstants.BackslashChar, StringSplitOptions.RemoveEmptyEntries);

Microsoft.Build.CommandLine.UnitTests (1)

CommandLineSwitches_Tests.cs (1)

1548string[] helpMessageLines = item.Value.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);

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

FileUtilities.cs (3)

Microsoft.Build.Engine.UnitTests (3)

Construction\SolutionFile_OldParser_Tests.cs (1)

2475string[] lines = solutionFileContent.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);

FileLogger_Tests.cs (2)

470string[] actualLines = actualContent.Split(MSBuildConstants.NewlineChar, StringSplitOptions.RemoveEmptyEntries); 471string[] expectedLines = expectedContent.Split(MSBuildConstants.NewlineChar, StringSplitOptions.RemoveEmptyEntries);

Microsoft.Build.Framework (1)

FileClassifier.cs (1)

279?.Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries)

Microsoft.Build.Tasks.CodeAnalysis (7)

src\Compilers\Core\MSBuildTask\CommandLineBuilderExtension.cs (2)

193string[] splits = parameter.Split(splitOn, /* omitEmptyEntries */ StringSplitOptions.RemoveEmptyEntries); 212string[] splits = parameter.Split(splitOn, /* omitEmptyEntries */ StringSplitOptions.RemoveEmptyEntries);

src\Compilers\Core\MSBuildTask\Csc.cs (1)

175var lines = output.Split(s_separators, StringSplitOptions.RemoveEmptyEntries);

src\Compilers\Core\MSBuildTask\Vbc.cs (1)

243var lines = output.Split(s_separator, StringSplitOptions.None);

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

src\Compilers\Shared\RuntimeHostInfo.cs (1)

59foreach (var item in path.Split(sep, StringSplitOptions.RemoveEmptyEntries))

Microsoft.Build.Tasks.CodeAnalysis.Sdk (7)

src\Compilers\Core\MSBuildTask\CommandLineBuilderExtension.cs (2)

src\Compilers\Core\MSBuildTask\Csc.cs (1)

175var lines = output.Split(s_separators, StringSplitOptions.RemoveEmptyEntries);

src\Compilers\Core\MSBuildTask\Vbc.cs (1)

243var lines = output.Split(s_separator, StringSplitOptions.None);

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

src\Compilers\Shared\RuntimeHostInfo.cs (1)

59foreach (var item in path.Split(sep, StringSplitOptions.RemoveEmptyEntries))

Microsoft.Build.Tasks.Core (16)

CanonicalError.cs (1)

373string[] explodedText = parsedMessage.text.Split(MSBuildConstants.SingleQuoteChar, StringSplitOptions.RemoveEmptyEntries);

CommandLineBuilderExtension.cs (2)

187string[] splits = parameter.Split(splitOn, /* omitEmptyEntries */ StringSplitOptions.RemoveEmptyEntries); 206string[] splits = parameter.Split(splitOn, /* omitEmptyEntries */ StringSplitOptions.RemoveEmptyEntries);

FileUtilities.cs (3)

MSBuild.cs (2)

417string[] expandedPropertyValues = t.Split(TargetAndPropertyListSeparators, StringSplitOptions.RemoveEmptyEntries); 435string[] expandedTargetValues = t.Split(TargetAndPropertyListSeparators, StringSplitOptions.RemoveEmptyEntries);

PlatformNegotiation.cs (2)

ResolveSDKReference.cs (3)

553return dependsOnSDK.Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim()).Where(y => y.Length > 0).ToList<string>(); 1215supportedArchitectures = SupportedArchitectures.Split(s_supportedArchitecturesSplitChars, StringSplitOptions.RemoveEmptyEntries); 1354string[] appxComponents = appxLocation.Key.Split(s_appxSplitChar, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim()).ToArray();

Telemetry.cs (2)

38foreach (string pair in EventData.Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries)) 40var item = pair.Split(MSBuildConstants.EqualsChar, 2, StringSplitOptions.RemoveEmptyEntries);

Unzip.cs (1)

337? pattern.Split([';'], StringSplitOptions.RemoveEmptyEntries).Select(FileMatcher.Normalize).ToArray()

Microsoft.Build.Tasks.UnitTests (1)

ToolTaskExtension_Tests.cs (1)

114string[] actual = t.GetResponseFileCommands().Split(MSBuildConstants.EnvironmentNewLine, StringSplitOptions.None);

Microsoft.Build.UnitTests.Shared (5)

EnvironmentProvider.cs (1)

51.Split(new char[] { Path.PathSeparator }, options: StringSplitOptions.RemoveEmptyEntries)

ObjectModelHelpers.cs (4)

511string[] expectedItemsStringSplit = expectedItemsString.Split(MSBuildConstants.CrLf, StringSplitOptions.RemoveEmptyEntries); 534string[] itemMetadataPieces = itemMetadataString.Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries); 1729foreach (var defaultTarget in (defaultTargets ?? string.Empty).Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries)) 2018string[] result = content.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);

Microsoft.Build.Utilities.Core (15)

CanonicalError.cs (1)

373string[] explodedText = parsedMessage.text.Split(MSBuildConstants.SingleQuoteChar, StringSplitOptions.RemoveEmptyEntries);

EventArgsFormatting.cs (1)

375string[] subStrings = s.Split(s_newLines, StringSplitOptions.None);

FileUtilities.cs (3)

ToolLocationHelper.cs (9)

TrackedDependencies\FileTracker.cs (1)

422string[] paths = Environment.GetEnvironmentVariable(pathEnvironmentVariableName).Split(pathSeparatorArray, StringSplitOptions.RemoveEmptyEntries);

Microsoft.Build.Utilities.UnitTests (1)

CommandLineBuilder_Tests.cs (1)

451string[] actual = c.ToString().Split(MSBuildConstants.EnvironmentNewLine, StringSplitOptions.None);

Microsoft.Cci.Extensions (1)

HostEnvironment.cs (1)

471return pathSet.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);

Microsoft.CodeAnalysis (3)

InternalUtilities\CompilerOptionParseUtilities.cs (2)

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

MetadataReader\PEModule.cs (1)

882from name in fullName.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries)

Microsoft.CodeAnalysis.Analyzers (12)

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer.cs (2)

706var parts = locationInfo.Split(new[] { AdditionalDocumentLocationInfoSeparator }, StringSplitOptions.None); 985var parts = s.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);

MetaAnalyzers\Fixers\AnalyzerReleaseTrackingFix.cs (1)

226switch (entry.Split(s_entryFieldSeparators, StringSplitOptions.None).Length)

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

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

173foreach (var line in child.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries))

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

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

58foreach (var platform in itemOptionValue.Split(s_itemMetadataValuesSeparators, StringSplitOptions.RemoveEmptyEntries))

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

395words = name.Split([WordSeparator], StringSplitOptions.RemoveEmptyEntries);

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

72var parts = @namespace.Split(NamespaceSeparatorArray, options: StringSplitOptions.RemoveEmptyEntries);

Microsoft.CodeAnalysis.Analyzers.UnitTests (3)

MetaAnalyzers\ReleaseTrackingAnalyzerTests.cs (3)

618var diagnosticText = (shippedText.Length > 0 ? shippedText : unshippedText).Split(new[] { Environment.NewLine }, StringSplitOptions.None).ElementAt(line - 1); 854var lineCount = (shippedText.Length > 0 ? shippedText : unshippedText).Split(new[] { Environment.NewLine }, StringSplitOptions.None).Length; 887var lineCount = (shippedText.Length > 0 ? shippedText : unshippedText).Split(new[] { Environment.NewLine }, StringSplitOptions.None).Length;

Microsoft.CodeAnalysis.AnalyzerUtilities (9)

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

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

173foreach (var line in child.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries))

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

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

58foreach (var platform in itemOptionValue.Split(s_itemMetadataValuesSeparators, StringSplitOptions.RemoveEmptyEntries))

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

395words = name.Split([WordSeparator], StringSplitOptions.RemoveEmptyEntries);

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

72var parts = @namespace.Split(NamespaceSeparatorArray, options: StringSplitOptions.RemoveEmptyEntries);

Microsoft.CodeAnalysis.BannedApiAnalyzers (9)

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

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

173foreach (var line in child.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries))

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

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

58foreach (var platform in itemOptionValue.Split(s_itemMetadataValuesSeparators, StringSplitOptions.RemoveEmptyEntries))

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

395words = name.Split([WordSeparator], StringSplitOptions.RemoveEmptyEntries);

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

72var parts = @namespace.Split(NamespaceSeparatorArray, options: StringSplitOptions.RemoveEmptyEntries);

Microsoft.CodeAnalysis.CodeStyle (6)

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

151var folders = relativeDirectoryPath.Split([Path.DirectorySeparatorChar], StringSplitOptions.RemoveEmptyEntries);

src\Analyzers\Core\Analyzers\OrderModifiers\OrderModifiersHelpers.cs (1)

73foreach (var piece in value.Split(s_comma, StringSplitOptions.RemoveEmptyEntries))

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

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

395words = name.Split([WordSeparator], StringSplitOptions.RemoveEmptyEntries);

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

72var parts = @namespace.Split(NamespaceSeparatorArray, options: StringSplitOptions.RemoveEmptyEntries);

Microsoft.CodeAnalysis.CodeStyle.Fixes (1)

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_DisposePattern.cs (1)

98var finalizerLines = finalizer.ToFullString().Split(['\r', '\n'], StringSplitOptions.RemoveEmptyEntries);

Microsoft.CodeAnalysis.CSharp (4)

Binder\Binder.cs (1)

956var lines = scope.ScopeDesignator.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);

CommandLine\CSharpCommandLineParser.cs (2)

1860foreach (var u in value.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)) 2000string[] kinds = value.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

Compiler\DocumentationCommentCompiler.cs (1)

808string[] lines = substitutedText.Split(s_newLineSequences, StringSplitOptions.None);

Microsoft.CodeAnalysis.CSharp.CodeStyle (1)

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

92var lines = commentText.Split([newLine], StringSplitOptions.None);

Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests (8)

CommandLineTests.cs (8)

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

CodeGen\CodeGenAsyncLocalsTests.cs (1)

35var actualLines = c.VisualizeIL(qualifiedMethodName).Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);

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

Emit\RuntimeProbing\ModuleCancellationTests.cs (1)

37var isInstrumented = string.Join(" ", il.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)).Contains(instrumentationIndicator);

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

EditAndContinue\CSharpEditAndContinueAnalyzerTests.cs (1)

765.Select(d => $"{d.Id}: {d.GetMessage().Split([Environment.NewLine], StringSplitOptions.None).First()}"));

SemanticSearch\CSharpSemanticSearchServiceTests.cs (2)

366var actualTrace = exception.StackTrace.JoinText().Split([Environment.NewLine], StringSplitOptions.None).AsSpan(); 435var actualTrace = exception.StackTrace.JoinText().Split([Environment.NewLine], StringSplitOptions.None).AsSpan()[0..2].ToArray();

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

Semantics\BindingAwaitTests.cs (1)

1899var calls = actualIL.Split(new[] { '\n', '\r' }, System.StringSplitOptions.RemoveEmptyEntries).Where(s => s.Contains("OnCompleted")).ToArray();

Semantics\OperatorTests.cs (1)

3212.Split(new[] { Environment.NewLine }, System.StringSplitOptions.RemoveEmptyEntries)

Semantics\OverloadResolutionTestBase.cs (1)

48.Split(new[] { Environment.NewLine }, System.StringSplitOptions.RemoveEmptyEntries)

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

Symbols\AnonymousTypesSemanticsTests.cs (1)

2141foreach (var line in source.Split(new String[] { Environment.NewLine }, StringSplitOptions.None))

Microsoft.CodeAnalysis.CSharp.Workspaces (1)

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

92var lines = commentText.Split([newLine], StringSplitOptions.None);

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

Formatting\FormattingTests.cs (1)

10354var lines = s.Split([Environment.NewLine], StringSplitOptions.None);

Microsoft.CodeAnalysis.EditorFeatures (1)

Interactive\InteractiveWindowResetCommand.cs (1)

122foreach (var argument in arguments.Split([' '], StringSplitOptions.RemoveEmptyEntries))

Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities (2)

QuickInfo\ToolTipAssert.cs (2)

206return string.Join(" Or ", stringValue.Split([',', ' '], StringSplitOptions.RemoveEmptyEntries).Select(value => $"{nameof(ContainerElementStyle)}.{value}")); 212return string.Join(" Or ", stringValue.Split([',', ' '], StringSplitOptions.RemoveEmptyEntries).Select(value => $"{nameof(ClassifiedTextRunStyle)}.{value}"));

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (3)

CodeGeneration\CodeGenerationTests.cs (1)

948var parts = statements.Split([delimiter], StringSplitOptions.RemoveEmptyEntries);

Diagnostics\IDEDiagnosticIDConfigurationTests.cs (1)

98expectedLines = expected.Split([Environment.NewLine], StringSplitOptions.RemoveEmptyEntries);

Structure\AbstractStructureTaggerProviderTests.cs (1)

19var buffer = EditorFactory.CreateBuffer(exportProvider, input.Split([Environment.NewLine], StringSplitOptions.None));

Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider.Utilities (1)

ResultProviderTestBase.cs (1)

482var parts = e.ToString().Split(new[] { ", " }, StringSplitOptions.RemoveEmptyEntries);

Microsoft.CodeAnalysis.Features (6)

Completion\Providers\SymbolCompletionItem.cs (1)

136var idList = symbolIds.Split(s_symbolSplitters, StringSplitOptions.RemoveEmptyEntries).ToList();

GenerateType\AbstractGenerateTypeService.Editor.cs (2)

482containers = GetNamespaceToGenerateInto().Split(['.'], StringSplitOptions.RemoveEmptyEntries); 487containers = GetNamespaceToGenerateIntoForUsageWithNamespace(targetProject, triggeringProject).Split(['.'], StringSplitOptions.RemoveEmptyEntries);

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

151var folders = relativeDirectoryPath.Split([Path.DirectorySeparatorChar], StringSplitOptions.RemoveEmptyEntries);

src\Analyzers\Core\Analyzers\OrderModifiers\OrderModifiersHelpers.cs (1)

73foreach (var piece in value.Split(s_comma, StringSplitOptions.RemoveEmptyEntries))

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_DisposePattern.cs (1)

98var finalizerLines = finalizer.ToFullString().Split(['\r', '\n'], StringSplitOptions.RemoveEmptyEntries);

Microsoft.CodeAnalysis.Features.Test.Utilities (2)

EditAndContinue\SourceMarkers.cs (1)

41=> from ids in match.Groups["Id"].Value.Split([','], StringSplitOptions.RemoveEmptyEntries)

SolutionExplorer\AbstractSolutionExplorerSymbolTreeItemProviderTests.cs (1)

39expected.Trim().Split(["\r\n"], StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()),

Microsoft.CodeAnalysis.LanguageServer (1)

DotnetCliHelper.cs (1)

137foreach (var item in path.Split(sep, StringSplitOptions.RemoveEmptyEntries))

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (9)

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

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

173foreach (var line in child.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries))

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

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

58foreach (var platform in itemOptionValue.Split(s_itemMetadataValuesSeparators, StringSplitOptions.RemoveEmptyEntries))

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

395words = name.Split([WordSeparator], StringSplitOptions.RemoveEmptyEntries);

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

72var parts = @namespace.Split(NamespaceSeparatorArray, options: StringSplitOptions.RemoveEmptyEntries);

Microsoft.CodeAnalysis.PublicApiAnalyzers (10)

DeclarePublicApiAnalyzer.cs (1)

337var namespaceStrings = namespacesString.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

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

173foreach (var line in child.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries))

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

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

58foreach (var platform in itemOptionValue.Split(s_itemMetadataValuesSeparators, StringSplitOptions.RemoveEmptyEntries))

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

395words = name.Split([WordSeparator], StringSplitOptions.RemoveEmptyEntries);

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

72var parts = @namespace.Split(NamespaceSeparatorArray, options: StringSplitOptions.RemoveEmptyEntries);

Microsoft.CodeAnalysis.PublicApiAnalyzers.CodeFixes (1)

PublicApiFixHelpers.cs (1)

47var split = equivalenceKey.Split(SemicolonSplit, StringSplitOptions.RemoveEmptyEntries);

Microsoft.CodeAnalysis.Rebuild.UnitTests (3)

RebuildCommandLineTests.cs (3)

334var args = new List<string>(commandLine.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)); 348args.AddRange(commandLineSuffix.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)); 499var args = new List<string>(commandLine.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries));

Microsoft.CodeAnalysis.ResxSourceGenerator (12)

AbstractResxGenerator.cs (3)

124noWarn = noWarnText.Split([',', ';'], StringSplitOptions.RemoveEmptyEntries).Select(i => i.Trim()).ToArray() ?? []; 207var exceptionLines = ex.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.None); 771foreach (var line in escapedTrimmedValue.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None))

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

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

173foreach (var line in child.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries))

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

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

58foreach (var platform in itemOptionValue.Split(s_itemMetadataValuesSeparators, StringSplitOptions.RemoveEmptyEntries))

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

395words = name.Split([WordSeparator], StringSplitOptions.RemoveEmptyEntries);

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

72var parts = @namespace.Split(NamespaceSeparatorArray, options: StringSplitOptions.RemoveEmptyEntries);

Microsoft.CodeAnalysis.ResxSourceGenerator.UnitTests (4)

ResxGeneratorTests.cs (4)

761var id = string.Join("_", noWarn.Replace(" ", "").Split(",", System.StringSplitOptions.TrimEntries | System.StringSplitOptions.RemoveEmptyEntries)); 795var id = string.Join("_", noWarn.Replace(" ", "").Split(",", System.StringSplitOptions.TrimEntries | System.StringSplitOptions.RemoveEmptyEntries));

Microsoft.CodeAnalysis.Scripting.TestUtilities (1)

ObjectFormatterTestBase.cs (1)

21foreach (var line in str.Split(new[] { Environment.NewLine + " " }, StringSplitOptions.None))

Microsoft.CodeAnalysis.Test.Utilities (4)

Assert\AssertEx.cs (2)

889str.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries); 994var stack = ex.StackTrace.Split(new[] { Environment.NewLine }, StringSplitOptions.None);

Assert\DiffUtil.cs (1)

92return s.Split(s_lineSplitChars, StringSplitOptions.RemoveEmptyEntries);

Compilation\OperationTreeVerifier.cs (1)

164var lines = text.Split(new[] { Environment.NewLine, "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries).Select(l => l.Trim()).ToArray();

Microsoft.CodeAnalysis.Workspaces (8)

PatternMatching\ContainerPatternMatcher.cs (1)

64var containerParts = container.Split(_containerSplitCharacters, StringSplitOptions.RemoveEmptyEntries);

PatternMatching\PatternMatcher.cs (1)

94pattern.Split(s_dotCharacterArray, StringSplitOptions.RemoveEmptyEntries),

Shared\Utilities\DocumentationComment.cs (1)

192var lines = text.Split(s_NewLineAsStringArray, StringSplitOptions.RemoveEmptyEntries);

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

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

395words = name.Split([WordSeparator], StringSplitOptions.RemoveEmptyEntries);

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

72var parts = @namespace.Split(NamespaceSeparatorArray, options: StringSplitOptions.RemoveEmptyEntries);

Workspace\CommandLineProject.cs (1)

200return directory.Split(s_folderSplitters, StringSplitOptions.RemoveEmptyEntries).ToImmutableArray();

Microsoft.CodeAnalysis.Workspaces.MSBuild (1)

MSBuild\MSBuildProjectLoader.Worker.cs (1)

463var pathNames = logicalPath.Split(s_directorySplitChars, StringSplitOptions.RemoveEmptyEntries);

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

MSBuild\ProjectFile\Extensions.cs (1)

63? [.. aliasesText.Split([','], StringSplitOptions.RemoveEmptyEntries).Select(a => a.Trim())]

MSBuild\ProjectFile\ProjectFile.cs (1)

277var folders = relativePath == null ? [] : relativePath.Split([PathUtilities.DirectorySeparatorChar, PathUtilities.AltDirectorySeparatorChar], StringSplitOptions.RemoveEmptyEntries).ToImmutableArray();

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests (2)

NewlyCreatedProjectsFromDotNetNew.cs (2)

104var lines = result.Output.Split(["\r", "\n"], StringSplitOptions.RemoveEmptyEntries); 120var columns = line.Split([" "], StringSplitOptions.RemoveEmptyEntries)

Microsoft.CodeAnalysis.Workspaces.Test.Utilities (1)

Workspaces\TestWorkspace_XmlConsumption.cs (1)

721var folderContainers = folderAttribute.Value.Split([PathUtilities.DirectorySeparatorChar], StringSplitOptions.RemoveEmptyEntries);

Microsoft.Data.Analysis.Tests (1)

DataFrame.IOTests.cs (1)

1104var text = reader.ReadToEnd().Split(["\r\n", "\r", "\n"], StringSplitOptions.None);

Microsoft.DotNet.Arcade.Sdk (2)

src\GenerateResxSource.cs (1)

429foreach (var line in escapedTrimmedValue.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None))

src\LocateDotNet.cs (1)

71var dotNetDir = paths.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault(p => File.Exists(Path.Combine(p, fileName)));

Microsoft.DotNet.ArcadeLogging (1)

PipelinesLogger.cs (1)

55_ignoredTargets.UnionWith(targetsNotLogged.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries));

Microsoft.DotNet.Build.Manifest (2)

MSBuildListSplitter.cs (1)

18return GetNamedProperties(input.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries));

VersionIdentifier.cs (1)

53string[] pathSegments = assetName.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);

Microsoft.DotNet.Build.Tasks.Installers (1)

src\GenerateJsonObjectString.cs (1)

122StringSplitOptions.RemoveEmptyEntries))

Microsoft.DotNet.Build.Tasks.Workloads.Tests (1)

SwixComponentTests.cs (1)

192Assert.Equal(2, componentSwr.Split(new[] { "vs.dependency" }, StringSplitOptions.None).Length);

Microsoft.DotNet.Helix.Client (2)

generated-code\PagedResponse.cs (2)

88foreach (var link in linkHeader.Split(new[] {','}, StringSplitOptions.RemoveEmptyEntries)) 100var parts = link.Split(new[] {';'}, StringSplitOptions.RemoveEmptyEntries);

Microsoft.DotNet.Helix.Sdk (1)

FindDotNetCliPackage.cs (1)

340string[] versionData = latestVersionContent.Split(Array.Empty<char>(), StringSplitOptions.RemoveEmptyEntries);

Microsoft.DotNet.NuGetRepack.Tests (1)

TestHelpers\DiffUtil.cs (1)

89return s.Split(s_lineSplitChars, StringSplitOptions.RemoveEmptyEntries);

Microsoft.DotNet.XliffTasks (1)

Model\XamlRuleDocument.cs (1)

198foreach (string? line in comment.Value.Split(new[] { '\n' }, System.StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()))

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

PromptBasedFunctionCallingChatClient.cs (1)

93foreach (var toolCallJson in content.Split(["<tool_call_json>"], StringSplitOptions.None))

VerbatimMultiPartHttpHandler.cs (1)

89string[] parts = bodyText.Split(new string[] { fullBoundary }, StringSplitOptions.None);

Microsoft.Extensions.DependencyModel (2)

DependencyContextPaths.cs (1)

49string[]? files = depsFiles?.Split(separator, StringSplitOptions.RemoveEmptyEntries);

Resolution\PackageCompilationAssemblyResolver.cs (1)

49return listOfDirectories.Split([Path.PathSeparator], StringSplitOptions.RemoveEmptyEntries);

Microsoft.Extensions.Diagnostics.ResourceMonitoring (2)

Linux\Disk\DiskStatsReader.cs (1)

72string[] parts = line.Split(Array.Empty<char>(), StringSplitOptions.RemoveEmptyEntries);

Linux\Network\LinuxNetworkUtilizationParser.cs (1)

68int numRanges = line.Split(range, ' ', StringSplitOptions.RemoveEmptyEntries);

Microsoft.Extensions.Logging.EventSource (1)

LoggingEventSource.cs (1)

426string[] ruleStrings = filterSpec.Split(s_semicolon, StringSplitOptions.RemoveEmptyEntries);

Microsoft.Extensions.ServiceDiscovery.Dns (4)

DnsSrvServiceEndpointProviderFactory.cs (2)

103var components = line.Split(' ', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);

Resolver\ResolvConf.cs (2)

24string[] tokens = line.Split(' ', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);

Microsoft.Extensions.ServiceDiscovery.Dns.Tests (3)

Resolver\LoopbackDnsServer.cs (1)

228var encodedLabels = name.Split('.', StringSplitOptions.RemoveEmptyEntries).Select(label => (ReadOnlyMemory<byte>)Encoding.UTF8.GetBytes(s_idnMapping.GetAscii(label)))

tests\Shared\Logging\XunitLoggerProvider.cs (2)

Microsoft.Maui.Controls (14)

Accelerator.cs (1)

68 var keys = text.Split(new char[] { Separator }, StringSplitOptions.RemoveEmptyEntries);

Brush\BrushTypeConverter.cs (5)

118 .Split(new[] { '(', ')', ',' }, StringSplitOptions.RemoveEmptyEntries); 127 var parts = part.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); 140 var parts = part.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); 173 var parts = GetNextPart().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); 325 var parts = part.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

Button\Button.cs (1)

587 string[] parts = strValue.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

DoubleCollectionConverter.cs (1)

33 string[] doubles = strValue.Split(new char[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries);

ListStringTypeConverter.cs (1)

26 return strValue.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).ToList();

ResourceDictionary.cs (1)

429 var parts = value.Split(new[] { ";assembly=" }, StringSplitOptions.RemoveEmptyEntries);

Routing.cs (1)

247 var parts = uri.OriginalString.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);

Shapes\MatrixTypeConverter.cs (1)

25 string[] strs = value.Split(new char[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries);

Shell\ShellUriHandler.cs (2)

163 static internal string[] RetrievePaths(string uri) => uri.Split(_pathSeparators, StringSplitOptions.RemoveEmptyEntries); 541 routeKey.Split(_pathSeparators, StringSplitOptions.RemoveEmptyEntries);

Microsoft.Maui.Controls.BindingSourceGen (1)

BindingCodeWriter.cs (1)

443 foreach (var line in lines.Split(LineSeparators, StringSplitOptions.RemoveEmptyEntries))

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

CompiledConverters\ListStringTypeConverter.cs (1)

23 var parts = value.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).ToList();

CompiledConverters\RDSourceTypeConverter.cs (1)

32 var parts = value.Split(new[] { ";assembly=" }, StringSplitOptions.RemoveEmptyEntries);

SetPropertiesVisitor.cs (1)

680 var parts = path.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries);

XamlCTask.cs (3)

50 Context.NoWarn = noWarn?.Split([';', ','], StringSplitOptions.RemoveEmptyEntries).Select(s => 63 Context.WarningsAsErrors = warningsAsErrors?.Split([';', ','], StringSplitOptions.RemoveEmptyEntries).Select(s => 76 Context.WarningsNotAsErrors = warningsNotAsErrors?.Split([';', ','], StringSplitOptions.RemoveEmptyEntries).Select(s =>

Microsoft.Maui.Controls.DesignTools (1)

ButtonContentDesignTypeConverter.cs (1)

25 string[] parts = stringValue.Split(Separators, StringSplitOptions.RemoveEmptyEntries);

Microsoft.Maui.Controls.Xaml (1)

PruneIgnoredNodesVisitor.cs (1)

28 var prefixes = propertyValue.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();

Microsoft.Maui.Essentials (1)

VersionTracking\VersionTracking.shared.cs (1)

329 => preferences.Get<string?>(key, null, sharedName)?.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries) ?? Array.Empty<string>();

Microsoft.Maui.Graphics (1)

PathBuilder.cs (1)

132 string[] args = pathAsString.Split(new[] { ' ', '\r', '\n', '\t', ',' }, StringSplitOptions.RemoveEmptyEntries);

Microsoft.ML.Core (1)

CommandLine\CmdParser.cs (1)

493nicks = attr.ShortName.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);

Microsoft.ML.Data (2)

Commands\SaveDataCommand.cs (1)

135.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToArray();

DataLoadSave\Text\TextSaver.cs (1)

459foreach (string line in CmdIndenter.GetIndentedCommandLine(str).Split(new[] { "\n", "\r" }, StringSplitOptions.RemoveEmptyEntries))

Microsoft.ML.LightGbm (4)

LightGbmMulticlassTrainer.cs (1)

257string[] lines = modelText.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);

LightGbmTrainerBase.cs (1)

405string[] lines = modelText.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);

WrappedLightGbmBooster.cs (2)

191string[] lines = modelString.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries); 204string[] lines = modelString.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);

Microsoft.ML.Maml (1)

HelpCommand.cs (1)

360var blocks = summary.Split(new[] { "\n", "\r" }, StringSplitOptions.RemoveEmptyEntries);

Microsoft.ML.NugetPackageVersionUpdater (3)

Program.cs (3)

32var splits = output.Split("\r\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries); 37var detailSplit = split.Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries); 55var projectFilePaths = projectFiles.Split(";".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);

Microsoft.ML.Parquet (1)

PartitionedPathUtils.cs (1)

71return cleanPath.Split(separators, StringSplitOptions.RemoveEmptyEntries);

Microsoft.VisualStudio.LanguageServices (5)

GenerateType\GenerateTypeDialogViewModel.cs (3)

304var fileNameInFullPathInContainers = this.FullFilePath.Split(['\\'], StringSplitOptions.RemoveEmptyEntries); 326var containers = folderPath.Split(['\\'], StringSplitOptions.RemoveEmptyEntries); 368if (this.FullFilePath.Split(['\\'], StringSplitOptions.RemoveEmptyEntries).Any(s => _reservedKeywords.Contains(s, StringComparer.OrdinalIgnoreCase)))

Preview\FileChange.cs (1)

137var split = excerpt.Split(["\r\n"], StringSplitOptions.RemoveEmptyEntries);

ProjectSystem\Legacy\AbstractLegacyProject.cs (1)

213folders = [.. linkFolderPath.Split(PathSeparatorCharacters, StringSplitOptions.RemoveEmptyEntries)];

Microsoft.VisualStudio.LanguageServices.CSharp (6)

CodeModel\CSharpCodeModelService.cs (3)

1283foreach (var line in value.Split(['\r', '\n'], StringSplitOptions.RemoveEmptyEntries)) 1357var lines = documentationComment.ToString().Split([newLine], StringSplitOptions.None); 1418foreach (var line in child.ToString().Split(['\r', '\n'], StringSplitOptions.RemoveEmptyEntries))

ProjectSystemShim\CSharpProjectShim.OptionsProcessor.cs (2)

164foreach (var warning in GetStringOption(compilerOptions, defaultValue: "").Split([' ', ',', ';'], StringSplitOptions.RemoveEmptyEntries)) 218var symbols = GetStringOption(CompilerOptions.OPTID_CCSYMBOLS, defaultValue: "").Split([';'], StringSplitOptions.RemoveEmptyEntries);

ProjectSystemShim\TempPECompilerService.cs (1)

83foreach (var reference in ((string)optionValue).Split(['|'], StringSplitOptions.RemoveEmptyEntries))

MSBuild (5)

EventArgsFormatting.cs (1)

375string[] subStrings = s.Split(s_newLines, StringSplitOptions.None);

FileUtilities.cs (3)

XMake.cs (1)

3319.SelectMany(parameter => parameter?.Split(s_commaSemicolon, StringSplitOptions.RemoveEmptyEntries) ?? [null]))

MSBuildTaskHost (2)

FileUtilities.cs (2)

1174string[] splitBase = fullBase.Split(MSBuildConstants.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries); 1175string[] splitPath = fullPath.Split(MSBuildConstants.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries);

mscorlib (1)

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

1087[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.StringSplitOptions))]

netstandard (1)

netstandard.cs (1)

2022[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.StringSplitOptions))]

PresentationCore (1)

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

101string[] split = tokens.Split(new Char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);

PresentationFramework (3)

Microsoft\Win32\FileDialog.cs (1)

692string[] tokens = filter.Split('|', StringSplitOptions.RemoveEmptyEntries);

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

632int segmentsLength = typeName.Split(segments, Colon, StringSplitOptions.TrimEntries);

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

1378string[] textParagraphs = textData.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.None);

PresentationUI (1)

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

658StringSplitOptions.RemoveEmptyEntries);

Replay (1)

src\Compilers\Shared\RuntimeHostInfo.cs (1)

59foreach (var item in path.Split(sep, StringSplitOptions.RemoveEmptyEntries))

Roslyn.Diagnostics.Analyzers (9)

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

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

173foreach (var line in child.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries))

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

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

58foreach (var platform in itemOptionValue.Split(s_itemMetadataValuesSeparators, StringSplitOptions.RemoveEmptyEntries))

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

395words = name.Split([WordSeparator], StringSplitOptions.RemoveEmptyEntries);

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

72var parts = @namespace.Split(NamespaceSeparatorArray, options: StringSplitOptions.RemoveEmptyEntries);

Roslyn.Diagnostics.CSharp.Analyzers (1)

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

92var lines = commentText.Split([newLine], StringSplitOptions.None);

Swaggatherer (1)

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (1)

18foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries))

System.ComponentModel.Composition (1)

System\ComponentModel\Composition\Hosting\ApplicationCatalog.cs (1)

87string[] probingPaths = relativeSearchPath.Split(';', StringSplitOptions.RemoveEmptyEntries);

System.Data.Common (1)

System\Data\DataTable.cs (1)

3710string[] split = sortString.Split(',', StringSplitOptions.TrimEntries);

System.Diagnostics.DiagnosticSource (2)

System\Diagnostics\Metrics\MetricsEventSource.cs (2)

717string[] specStrings = metricsSpecs.Split(s_instrumentSeparators, StringSplitOptions.RemoveEmptyEntries); 753string[] specStrings = base2ExponentialHistogramSpec.Split(Base2ExponentialHistogramSpecSeparators, StringSplitOptions.RemoveEmptyEntries);

System.Net.Http (2)

System\Net\Http\SocketsHttpHandler\HttpEnvironmentProxy.cs (2)

114_bypass = bypassList?.Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);

System.Net.HttpListener (2)

System\Net\WebSockets\HttpWebSocket.cs (2)

59string[] requestProtocols = clientSecWebSocketProtocol.Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);

System.Net.Mail (2)

System\Net\Mail\SmtpConnection.Auth.cs (1)

53string[] authTypes = extension.Remove(0, SizeOfAuthExtension).Split(s_authExtensionSplitters, StringSplitOptions.RemoveEmptyEntries);

System\Net\Mime\MimeBasePart.cs (1)

58string[] substringsToDecode = value.Split(s_headerValueSplitChars, StringSplitOptions.RemoveEmptyEntries);

System.Net.NetworkInformation (8)

System\Net\NetworkInformation\StringParsingHelpers.Addresses.cs (1)

60string[] token = line.Split(' ', StringSplitOptions.RemoveEmptyEntries);

System\Net\NetworkInformation\StringParsingHelpers.Connections.cs (6)

33v4connections = tcp4FileContents.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 43v6connections = tcp6FileContents.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 113v4connections = tcp4FileContents.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 123v6connections = tcp6FileContents.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 193v4connections = udp4FileContents.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 203v6connections = udp6FileContents.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);

System\Net\NetworkInformation\StringParsingHelpers.Statistics.cs (1)

416int pieceCount = lineSpan.SplitAny(pieces, " :", StringSplitOptions.RemoveEmptyEntries);

System.Net.Primitives (1)

System\Net\Cookie.cs (1)

518string[] ports = value.Split(PortSplitDelimiters, StringSplitOptions.RemoveEmptyEntries);

System.Private.CoreLib (65)

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

src\libraries\System.Private.CoreLib\src\System\Runtime\Loader\AssemblyDependencyResolver.cs (1)

200return pathsList.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries);

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

System.Private.CoreLib.Generators (2)

NativeRuntimeEventSourceGenerator.cs (2)

189foreach (string? kw in keywords.Split([' '], StringSplitOptions.RemoveEmptyEntries)) 301.Split([' '], StringSplitOptions.RemoveEmptyEntries)

System.Private.Xml (3)

System\Xml\Serialization\ReflectionXmlSerializationWriter.cs (1)

1011IEnumerable<string> defaultEnumFlagValues = defaultValue!.ToString()!.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries);

System\Xml\XmlConvert.cs (2)

1371return value.Split(WhitespaceChars, StringSplitOptions.RemoveEmptyEntries); 1374internal static string[] SplitString(string value, StringSplitOptions splitStringOptions)

System.Runtime (1)

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

777[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.StringSplitOptions))]

System.Security.Cryptography (1)

System\Security\Cryptography\X509Certificates\OpenSslCachedSystemStoreProvider.cs (1)

340string[] directories = rootDirectory.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries);

System.Text.Json.SourceGeneration (1)

Helpers\SourceGeneratorHelpers.cs (1)

15IEnumerable<string> values = value.ToString().Split(s_enumSeparator, StringSplitOptions.RemoveEmptyEntries)

System.Text.RegularExpressions.Generator (2)

RegexGenerator.Emitter.cs (1)

5440string[] parts = s.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

UpgradeToGeneratedRegexCodeFixer.cs (1)

327string[] parts = stringifiedRegexOptions.Split(s_comma, StringSplitOptions.RemoveEmptyEntries);

System.Windows.Forms (3)

System\Resources\ResXDataNode.cs (1)

676string[] typeParts = typeName.Split(',', StringSplitOptions.TrimEntries);

System\Windows\Forms\DataBinding\BindingSource.cs (1)

975string[] split = sortString.Split(',', StringSplitOptions.TrimEntries);

System\Windows\Forms\Input\KeysConverter.cs (1)

162string[] tokens = text.Split('+', StringSplitOptions.TrimEntries);

TagHelpersWebSite (1)

TagHelpers\TagCloudViewComponentTagHelper.cs (1)

23.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)

Templates.Blazor.Tests (1)

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (1)

18foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries))

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

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (1)

18foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries))

Templates.Blazor.WebAssembly.Tests (1)

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (1)

18foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries))

Templates.Mvc.Tests (1)

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (1)

18foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries))

Templates.Tests (1)

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (1)

18foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries))

Test.Utilities (10)

CodeMetricsTestsBase.cs (2)

88var actualMetricsTextLines = actualMetricsText.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); 89var expectedMetricsTextLines = expectedMetricsText.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

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

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

58foreach (var platform in itemOptionValue.Split(s_itemMetadataValuesSeparators, StringSplitOptions.RemoveEmptyEntries))

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

395words = name.Split([WordSeparator], StringSplitOptions.RemoveEmptyEntries);

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

72var parts = @namespace.Split(NamespaceSeparatorArray, options: StringSplitOptions.RemoveEmptyEntries);

TestProject.IntegrationServiceA (1)

Program.cs (1)

9? TestResourceNamesExtensions.Parse(skipResourcesValue.Split(',', StringSplitOptions.RemoveEmptyEntries))

Text.Analyzers (9)

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

23return features.Split(new[] { ';', ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 30foreach (var feature in commaFeatures.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

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

173foreach (var line in child.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries))

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

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

58foreach (var platform in itemOptionValue.Split(s_itemMetadataValuesSeparators, StringSplitOptions.RemoveEmptyEntries))

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

395words = name.Split([WordSeparator], StringSplitOptions.RemoveEmptyEntries);

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

72var parts = @namespace.Split(NamespaceSeparatorArray, options: StringSplitOptions.RemoveEmptyEntries);

vbc (1)

src\Compilers\Shared\RuntimeHostInfo.cs (1)

59foreach (var item in path.Split(sep, StringSplitOptions.RemoveEmptyEntries))

VBCSCompiler (1)

src\Compilers\Shared\RuntimeHostInfo.cs (1)

59foreach (var item in path.Split(sep, StringSplitOptions.RemoveEmptyEntries))

Wasm.Performance.ConsoleHost (1)

src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (1)

18foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries))

xunit.assert (3)

Sdk\Exceptions\CollectionException.cs (1)

56 .Split(crlfSeparators, StringSplitOptions.RemoveEmptyEntries)

Sdk\Exceptions\ExceptionUtility.cs (2)

49 foreach (var line in stack.Split(new[] { Environment.NewLine }, StringSplitOptions.None)) 94 .Split(new[] { Environment.NewLine }, StringSplitOptions.None)

xunit.console (3)

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\DependencyContextPaths.cs (1)

47var files = depsFiles?.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\Resolution\PackageCompilationAssemblyResolver.cs (1)

49return listOfDirectories.Split(new char [] { Path.PathSeparator }, StringSplitOptions.RemoveEmptyEntries );

common\AssemblyResolution\XunitPackageCompilationAssemblyResolver.cs (1)

36results = probeDirectories.Split(new char[] { Path.PathSeparator }, StringSplitOptions.RemoveEmptyEntries).ToList();