Split

408 references to Split

CodeStyleConfigFileGenerator (1)

Program.cs (1)

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

dotnet-svcutil-lib (27)

CodeDomFixup\CodeDomHelpers.cs (1)

249name.Split('.').All(namespacePart => new CSharpCodeProvider().IsValidIdentifier(namespacePart));

FrameworkFork\Microsoft.CodeDom\Microsoft\CSharpCodeProvider.cs (1)

3268string[] names = e.Name.Split('.');

FrameworkFork\Microsoft.Xml\Xml\schema\AstTree.cs (1)

576string[] xpath = xPath.Split('|');

FrameworkFork\Microsoft.Xml\Xml\Serialization\CodeIdentifier.cs (2)

222string[] parts = ns.Split(new char[] { '.' }); 274string[] names = identifier.Split(new char[] { '.', ',', '<', '>' });

FrameworkFork\Microsoft.Xml\Xml\Serialization\XmlCodeExporter.cs (2)

230string[] values = ((string)value).Split(null); 328string[] vals = defaultValue.Trim().Split(null);

FrameworkFork\Microsoft.Xml\Xml\Serialization\XmlCustomFormatter.cs (2)

105string[] toks = nmTokens.Split(new char[] { ' ' }); 390string[] parts = val.Split(null);

FrameworkFork\Microsoft.Xml\Xml\Serialization\XmlSerializationReader.cs (1)

1101dimensions = arraySize.Split(null);

FrameworkFork\Microsoft.Xml\Xml\Serialization\XmlSerializationWriter.cs (1)

1739string[] values = ((string)defaultValue).Split(null);

FrameworkFork\Microsoft.Xml\Xml\Serialization\XmlSerializationWriterILGen.cs (2)

211string[] values = ((string)defaultValue).Split(null); 2610String[] vars = initValue.Source.Split('.');

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

323string[] keyval = rawDnsEntries[i].Split(X509SubjectAlternativeNameConstants.Delimiter);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\WebSocketTransportSettings.cs (1)

103if (value.Split(WebSocketHelper.ProtocolSeparators).Length > 1)

FrameworkFork\System.ServiceModel\System\ServiceModel\Security\SecurityUtils.cs (2)

963string[] partsWithSlashDelimiter = username.Split('\\'); 964string[] partsWithAtDelimiter = username.Split('@');

FrameworkFork\System.ServiceModel\System\ServiceModel\Security\XmlHelper.cs (1)

281string[] parts = qName.Split(':');

FrameworkFork\System.Web.Services\Services\Description\ServiceDescription.cs (1)

1238_parameters = value.Split(new char[] { ' ' });

FrameworkFork\System.Web.Services\Services\Description\ServiceDescriptionSerializer.cs (1)

9384string[] vals = listValues.Split(null);

FrameworkFork\System.Web.Services\Services\Description\SoapFormatExtensions.cs (1)

155_parts = value.Split(new char[] { ' ' });

Metadata\HttpAuthenticationHelper.cs (1)

108authenticationSchemes = schemesString.Split(',');

Metadata\MetadaExchangeResolver.cs (1)

451string[] paramDecls = contentType.Split(new char[] { ';' });

Shared\Options\OptionValueParser.cs (1)

214var parts = stringValue.Split(',');

Shared\Options\WCFCSUpdateOptions.cs (1)

168var parts = stringValue.Split(',');

Shared\ProjectDependency.cs (1)

220var values = processedSpec.Split(new char[] { ',' });

Shared\Utilities\PathHelper.cs (1)

42.Split(new char[] { '/', '\\' })

GetDocument.Insider (1)

Commands\GetDocumentCommandWorker.cs (1)

411documentName.Split(_invalidFilenameCharacters));

installer.tasks (1)

StaticFileRegeneration\RegenerateThirdPartyNotices.cs (1)

84content = TpnDocument.Parse(tpnContent.Split(NewlineChars));

InteractiveHost.UnitTests (1)

AbstractInteractiveHostTests.cs (1)

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

Metrics (3)

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

45var guids = propertyValue.Split(';').Select(g => g.Trim()).ToImmutableArray();

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

162foreach (var kindStr in value.Split(','))

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

210foreach (var commentPart in comment.Split('\r', '\n'))

Metrics.Legacy (3)

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

45var guids = propertyValue.Split(';').Select(g => g.Trim()).ToImmutableArray();

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

162foreach (var kindStr in value.Split(','))

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

210foreach (var commentPart in comment.Split('\r', '\n'))

Microsoft.Analyzers.Local (5)

ApiLifecycle\Utils.cs (5)

24var substrings = typeSignature.Split(_colon); 28? substrings[1].Split(_comma).Select(x => x.Trim()).ToArray() 29: substrings[2].Split(_comma).Select(x => x.Trim()).ToArray(); 35var type = typeSignature.Split(_colon)[0]; 49var substrings = typeSignature.Split(_colon);

Microsoft.Arcade.Test.Common (1)

AssertEx.cs (1)

400var inputLines = input.Split('\n', '\r');

Microsoft.AspNetCore.Authorization (2)

AuthorizationPolicy.cs (2)

152var rolesSplit = authorizeDatum.Roles?.Split(','); 160var authTypesSplit = authorizeDatum.AuthenticationSchemes?.Split(',');

Microsoft.AspNetCore.DataProtection (1)

Internal\ContainerUtils.cs (1)

55var fields = line.Split(new[] { '\t', ' ' });

Microsoft.AspNetCore.InternalTesting (1)

xunit\SkipOnHelixAttribute.cs (1)

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

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

RequestBodyTests.cs (1)

201string[] lines = response.Split('\r', '\n');

Microsoft.Build (24)

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

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

BackEnd\Components\Scheduler\SchedulingPlan.cs (2)

373string[] values = line.Split(MSBuildConstants.SpaceChar); 403string[] values = line.Split(MSBuildConstants.SpaceChar);

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

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

Construction\ProjectRootElement.cs (1)

1944foreach (string sdk in sdks.Split(MSBuildConstants.SemicolonChar).Select(i => i.Trim()))

Construction\Solution\SolutionFile.cs (5)

1437string[] projectReferenceEntries = propertyValue.Split([';'], StringSplitOptions.RemoveEmptyEntries); 1650string[] configurationNames = str.Split(nameValueSeparators); 1676string[] configurationPlatformParts = fullConfigurationName.Split(SolutionConfigurationInSolution.ConfigurationPlatformSeparatorArray); 1727string[] nameValue = str.Split('='); 1773string[] configurationPlatformParts = configurationPlatform.Split(SolutionConfigurationInSolution.ConfigurationPlatformSeparatorArray);

Construction\Solution\SolutionProjectGenerator.cs (1)

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

Evaluation\Expander\WellKnownFunctions.cs (1)

289returnVal = text.Split(separator[0]);

FileMatcher.cs (1)

454string[] parts = path.Split(directorySeparatorCharacters);

Graph\ProjectInterpretation.cs (1)

143string[] configurationPlatformParts = projectConfiguration.Split(SolutionConfiguration.ConfigPlatformSeparator[0]);

Instance\TaskRegistry.cs (1)

730string[] nameComponents = taskName.Split('.');

Logging\ConsoleLogger.cs (1)

117string[] parameterComponents = _parameters.Split(LoggerParametersHelper.s_parameterDelimiters);

Logging\DistributedLoggers\ConfigurableForwardingLogger.cs (1)

75string[] parameterComponents = _loggerParameters.Split(s_parameterDelimiters);

Logging\DistributedLoggers\DistributedFileLogger.cs (2)

46string[] parameterComponents = this.Parameters.Split(s_fileLoggerParameterDelimiters); 51string[] parameterAndValue = parameterComponents[param].Split(s_fileLoggerParameterValueSplitCharacter);

Logging\FileLogger.cs (2)

180foreach (string parameter in Parameters.Split(s_fileLoggerParameterDelimiters)) 187var parameterAndValue = parameter.Split(s_fileLoggerParameterValueSplitCharacter);

PlatformNegotiation.cs (1)

110string[] keyVal = s.Trim().Split(MSBuildConstants.EqualsChar);

Utilities\EngineFileUtilities.cs (1)

575foreach (string regex in wildCards.Split(MSBuildConstants.SemicolonChar))

Utilities\NuGetFrameworkWrapper.cs (1)

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

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

Construction\ConstructionEditing_Tests.cs (1)

3252var splits = expectedItem.Split(MSBuildConstants.NewlineChar);

Microsoft.Build.Engine.UnitTests (1)

BackEnd\MockTaskBuilder.cs (1)

107targetBuilderCallback.LegacyCallTarget(taskInstance.GetParameter("Targets").Split(MSBuildConstants.SemicolonChar), false, taskInstance.Location);

Microsoft.Build.Framework (3)

Logging\LoggerParametersHelper.cs (2)

53foreach (string parameter in parametersString.Split(s_parameterDelimiters)) 60string[] parameterAndValue = parameter.Split(s_parameterValueSplitCharacter);

Sdk\SdkReference.cs (1)

87var parts = sdk.Split(MSBuildConstants.ForwardSlash).Select(i => i.Trim()).ToArray();

Microsoft.Build.Tasks.CodeAnalysis (1)

Csc.cs (1)

456string[] allIdentifiers = originalDefineConstants.Split(new char[] { ',', ';', ' ' });

Microsoft.Build.Tasks.CodeAnalysis.UnitTests (1)

TestUtilities\DotNetSdkTestBase.cs (1)

78dotnetInstallDir = Environment.GetEnvironmentVariable("PATH")?.Split(Path.PathSeparator).FirstOrDefault(isMatchingDotNetInstance);

Microsoft.Build.Tasks.Core (15)

AssemblyDependency\GenerateBindingRedirects.cs (1)

256var oldVersionRange = oldVersionAttribute.Value.Split(MSBuildConstants.HyphenChar);

AssemblyFoldersEx.cs (1)

277string[] platforms = platformValue.Split(MSBuildConstants.SemicolonChar);

AssignProjectConfiguration.cs (3)

307string[] configurationPlatformParts = projectConfiguration.Split(SolutionConfiguration.ConfigPlatformSeparator); 392string[] mappings = mappingList.Split(MSBuildConstants.SemicolonChar); 396string[] platforms = mapping.Split(MSBuildConstants.EqualsChar);

CreateManifestResourceName.cs (2)

355string[] subNames = name.Split(MSBuildConstants.DotChar); 385string[] subNames = name.Split(MSBuildConstants.ForwardSlashBackslash);

FileMatcher.cs (1)

454string[] parts = path.Split(directorySeparatorCharacters);

ManifestUtil\PathUtil.cs (1)

40return path.Split(MSBuildConstants.DirectorySeparatorChar);

MSBuild.cs (4)

224undefinePropertiesArray = RemoveProperties.Split(MSBuildConstants.SemicolonChar); 516log, ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("General.OverridingProperties", projectNames[i]), "Properties", projects[i].GetMetadata("Properties").Split(MSBuildConstants.SemicolonChar), 534string[] propertiesToUndefine = projectUndefineProperties.Split(MSBuildConstants.SemicolonChar); 556log, ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("General.AdditionalProperties", projectNames[i]), "AdditionalProperties", projects[i].GetMetadata("AdditionalProperties").Split(MSBuildConstants.SemicolonChar),

PlatformNegotiation.cs (1)

110string[] keyVal = s.Trim().Split(MSBuildConstants.EqualsChar);

Unzip.cs (1)

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

Microsoft.Build.Tasks.UnitTests (1)

WriteCodeFragment_Tests.cs (1)

1178actualContent.Split(MSBuildConstants.CrLf)

Microsoft.Build.UnitTests.Shared (1)

ObjectModelHelpers.cs (1)

1836var splits = path.Split(MSBuildConstants.ForwardSlashBackslash);

Microsoft.Build.Utilities.Core (5)

AssemblyFoldersEx.cs (1)

277string[] platforms = platformValue.Split(MSBuildConstants.SemicolonChar);

ExtensionSDK.cs (2)

153string[] properties = moniker.Split(MSBuildConstants.CommaChar); 157string[] words = property.Split(MSBuildConstants.EqualsChar);

FileMatcher.cs (1)

454string[] parts = path.Split(directorySeparatorCharacters);

ToolTask.cs (1)

1320.Split(MSBuildConstants.PathSeparatorChar)?

Microsoft.Cci.Extensions (1)

Writers\CSharp\CSDeclarationWriter.Attributes.cs (1)

76string.Join("|", ops.ToString().Split(',').Select(x => "System.Runtime.CompilerServices.MethodImplOptions." + x.TrimStart())) :

Microsoft.CodeAnalysis (3)

FileSystem\PathUtilities.cs (1)

632var pathParts = path.Split(s_pathChars);

PEWriter\MetadataWriter.DynamicAnalysis.cs (1)

242foreach (var part in name.Split(separator))

SourceGeneration\Nodes\SyntaxValueProvider_ForAttributeWithMetadataName.cs (1)

84? MetadataTypeName.FromFullName(fullyQualifiedMetadataName.Split(s_nestedTypeNameSeparators).Last())

Microsoft.CodeAnalysis.Analyzers (7)

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer_IdRangeAndCategoryValidation.cs (3)

251var parts = contents.Split(':'); 276var ranges = parts[1].Split(','); 306var rangeParts = range.Split('-');

MetaAnalyzers\ReleaseTrackingHelper.cs (1)

174var parts = lineText.Split('|').Select(s => s.Trim()).ToArray();

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

45var guids = propertyValue.Split(';').Select(g => g.Trim()).ToImmutableArray();

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

162foreach (var kindStr in value.Split(','))

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

210foreach (var commentPart in comment.Split('\r', '\n'))

Microsoft.CodeAnalysis.AnalyzerUtilities (3)

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

45var guids = propertyValue.Split(';').Select(g => g.Trim()).ToImmutableArray();

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

162foreach (var kindStr in value.Split(','))

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

210foreach (var commentPart in comment.Split('\r', '\n'))

Microsoft.CodeAnalysis.BannedApiAnalyzers (3)

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

45var guids = propertyValue.Split(';').Select(g => g.Trim()).ToImmutableArray();

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

162foreach (var kindStr in value.Split(','))

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

210foreach (var commentPart in comment.Split('\r', '\n'))

Microsoft.CodeAnalysis.CodeStyle (16)

src\Analyzers\Core\Analyzers\FileHeaders\AbstractFileHeaderDiagnosticAnalyzer.cs (2)

86var reformattedCopyrightTextParts = expectedFileHeader.Replace("\r\n", "\n").Split('\n'); 87var fileHeaderCopyrightTextParts = copyrightText.Replace("\r\n", "\n").Split('\n');

src\Analyzers\Core\Analyzers\FileHeaders\AbstractFileHeaderHelper.cs (1)

78var triviaStringParts = commentText.Span.Trim().ToString().Replace("\r\n", "\n").Split('\n');

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

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

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

372foreach (var part in userExclusions.Split(','))

src\Analyzers\Core\Analyzers\ValidateFormatString\AbstractValidateFormatStringDiagnosticAnalyzer.cs (2)

381? textInsideBrackets.Split(',')[0] 382: textInsideBrackets.Split(':')[0];

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

632var pathParts = path.Split(s_pathChars);

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

182var lines = triviaText.Split('\n');

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

98let nameSplit = kvp.Key.Split('.')

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (3)

133foreach (var symbolSpecApplicableKind in symbolSpecApplicableKinds.Split(',').Select(x => x.Trim())) 211foreach (var symbolSpecApplicableAccessibility in symbolSpecApplicableAccessibilities.Split(',').Select(x => x.Trim())) 266foreach (var symbolSpecRequiredModifier in symbolSpecRequiredModifiers.Split(',').Select(x => x.Trim()))

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

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

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

27var parts = folders.SelectMany(folder => folder.Split(NamespaceSeparatorArray)).SelectAsArray(syntaxFacts.EscapeIdentifier); 32!rootNamespace.Split(NamespaceSeparatorArray).All(syntaxFacts.IsValidIdentifier))

Microsoft.CodeAnalysis.CodeStyle.Fixes (2)

src\Analyzers\Core\CodeFixes\FileHeaders\AbstractFileHeaderCodeFixProvider.cs (1)

209var lines = copyrightText.Split('\n');

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

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

Microsoft.CodeAnalysis.CSharp (1)

Symbols\AssemblySymbol.cs (1)

697var parts = metadataName.Split(s_nestedTypeNameSeparators);

Microsoft.CodeAnalysis.CSharp.CodeStyle (3)

src\Analyzers\CSharp\Analyzers\ConvertProgram\ConvertProgramAnalysis_TopLevelStatements.cs (1)

40var mainTypeName = mainTypeFullName?.Split('.').Last();

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\CSharpFormattingOptions2.Parsers.cs (1)

21var tokens = list.Split(',');

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

Debugging\ProximityExpressionsGetterTests.cs (1)

96{string.Join(Environment.NewLine, body.ReplaceLineEndings("\n").Split('\n').Select(line => line == "" ? line : $" {line}"))}

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

CodeGen\CodeGenExprLambdaTests.cs (1)

6398string[] expected_strs = expectedOutput.Trim().Split(delimit);

Microsoft.CodeAnalysis.CSharp.Workspaces (3)

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\CSharpFormattingOptions2.Parsers.cs (1)

21var tokens = list.Split(',');

Workspace\LanguageServices\CSharpSyntaxTreeFactoryService.cs (1)

45preprocessorSymbols: metadata.TryGetValue("define", out var defines) ? defines.Split(',') : null);

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

Formatting\FormattingTests.cs (1)

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

Microsoft.CodeAnalysis.EditorFeatures (3)

DocumentationComments\CopilotGenerateDocumentationCommentProvider.cs (1)

270var words = copilotText.Split(' ');

EditorConfigSettings\Updater\SettingsUpdateHelper.cs (1)

255var splicedFileExtensions = mostRecentHeaderText[(nameExtensionSplitIndex + 1)..].Split(',', ' ', '{', '}');

Interactive\InteractiveWindowResetCommand.cs (1)

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

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

AbstractCommandHandlerTestState.cs (1)

246var lines = text.Split('\r');

AutomaticCompletion\AbstractAutomaticLineEnderTests.cs (1)

57var lines = value.Split('\n');

Classification\FormattedClassification.cs (2)

53var parts = remainder.Split(' '); 212return $"{string.Join("", trimmedClassification.Split(' ').Select(Capitalize))}(\"{Text}\")";

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}"));

Rename\RenamerTests.cs (1)

113var splitPath = filePath.Split('\\');

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (4)

CodeGeneration\CodeGenerationTests.cs (1)

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

Diagnostics\IDEDiagnosticIDConfigurationTests.cs (1)

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

EmbeddedLanguages\StackFrame\StackFrameSyntaxFactory.cs (1)

109var identifiers = s.Split('.');

Structure\AbstractStructureTaggerProviderTests.cs (1)

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

Microsoft.CodeAnalysis.EditorFeatures2.UnitTests (2)

FindReferences\FindReferencesTests.vb (2)

130r.SymbolUsageInfo.TypeOrNamespaceUsageInfoOpt.ToString().Split(","c).Select(Function(s) s.Trim).SetEquals(typeOrNamespaceUsageInfoFieldNames) 329r.SymbolUsageInfo.TypeOrNamespaceUsageInfoOpt.ToString().Split(","c).Select(Function(s) s.Trim).SetEquals(typeOrNamespaceUsageInfoFieldNames)

Microsoft.CodeAnalysis.ExpressionEvaluator.FunctionResolver (2)

MetadataDecoder.cs (1)

258var parts = namespaceName.Split('.');

MetadataResolver.cs (1)

168var parts = namespaceName.Split('.');

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

Debugger\Engine\DkmClrValue.cs (1)

277var rawFormatSpecifiers = name.Substring(commaIndex + 1).Split(',');

Microsoft.CodeAnalysis.Features (13)

CodeFixes\Configuration\ConfigurationUpdater.cs (1)

579var splicedFileExtensions = mostRecentHeaderText[(nameExtensionSplitIndex + 1)..].Split(',', ' ', '{', '}');

CodeRefactorings\MoveType\AbstractMoveTypeService.cs (1)

185var fileNameParts = documentNameWithoutExtension.Split('.', '+');

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (2)

183|| (targetNamespace.Length > 0 && !targetNamespace.Split(s_dotSeparator).All(syntaxFacts.IsValidIdentifier))) 383=> @namespace?.Split(s_dotSeparator).ToImmutableArray() ?? default;

CodeRefactorings\SyncNamespace\AbstractSyncNamespaceCodeRefactoringProvider.MoveFileCodeAction.cs (1)

61: state.RelativeDeclaredNamespace.Split(['.']).ToImmutableArray();

Completion\CommonCompletionItem.cs (1)

85var parts = encoded.Split(s_descriptionSeparators).Select(t => t.Unescape('\\')).ToArray();

ExternalAccess\UnitTesting\API\UnitTestingSearchHelpers.cs (1)

110var pieces = fullyQualifiedTypeName.Split(s_splitCharacters);

GenerateType\AbstractGenerateTypeService.Editor.cs (2)

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

NavigateTo\RoslynNavigateToItem.cs (1)

227parts.AddRange(fileName.Split(s_dotArray));

PdbSourceDocument\ImplementationAssemblyLookupService.cs (1)

44var pathParts = referencedDllPath.Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);

PdbSourceDocument\SourceLinkMap.cs (1)

194var escapedPath = string.Join("/", path[file.Path.Length..].Split(['/', '\\']).Select(Uri.EscapeDataString));

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

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

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

EditAndContinue\SourceMarkers.cs (1)

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

Microsoft.CodeAnalysis.InteractiveHost (1)

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

632var pathParts = path.Split(s_pathChars);

Microsoft.CodeAnalysis.LanguageServer.Protocol (1)

Extensions\ProtocolConversions.cs (1)

254var parts = absolutePath.Split(s_dirSeparators);

Microsoft.CodeAnalysis.PublicApiAnalyzers (1)

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

210foreach (var commentPart in comment.Split('\r', '\n'))

Microsoft.CodeAnalysis.PublicApiAnalyzers.CodeFixes (2)

DeclarePublicApiFix.cs (2)

46.Split(DeclarePublicApiAnalyzer.ApiNamesOfSiblingsToRemovePropertyBagValueSeparator.ToCharArray()) 279var namesToRemove = siblingNamesToRemove.Split(DeclarePublicApiAnalyzer.ApiNamesOfSiblingsToRemovePropertyBagValueSeparator.ToCharArray());

Microsoft.CodeAnalysis.ResxSourceGenerator (3)

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

45var guids = propertyValue.Split(';').Select(g => g.Trim()).ToImmutableArray();

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

162foreach (var kindStr in value.Split(','))

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

210foreach (var commentPart in comment.Split('\r', '\n'))

Microsoft.CodeAnalysis.Test.Utilities (1)

Assert\AssertEx.cs (1)

625var inputLines = input.Split('\n', '\r');

Microsoft.CodeAnalysis.UnitTests (1)

Collections\DebuggerAttributes.cs (1)

145var segments = attrText.Split(new[] { '{', '}' });

Microsoft.CodeAnalysis.VisualBasic (1)

Symbols\AssemblySymbol.vb (1)

560Dim parts() As String = metadataName.Split(s_nestedTypeNameSeparators)

Microsoft.CodeAnalysis.VisualBasic.ExpressionCompiler (1)

EvaluationContext.vb (1)

599Dim nameParts = qualifiedName.Split("."c)

Microsoft.CodeAnalysis.VisualBasic.Workspaces (2)

CodeCleanup\Providers\ReduceTokensCodeCleanupProvider.vb (2)

257Dim parts As String() = valueText.Split("."c) 260Dim partsAfterDot = parts(1).Split("E"c)

Microsoft.CodeAnalysis.Workspaces (6)

CodeCleanup\AbstractCodeCleanerService.cs (1)

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

Editing\SyntaxGenerator.cs (1)

1904var parts = dottedName.Split(s_dotSeparator);

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

632var pathParts = path.Split(s_pathChars);

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

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

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

Microsoft.CodeAnalysis.Workspaces.MSBuild (1)

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

32.Split(Path.PathSeparator)

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

MSBuild\ProjectFile\Extensions.cs (1)

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

MSBuild\ProjectFile\ProjectFile.cs (3)

65var targetFrameworks = targetFrameworksValue.Split(';'); 271return [.. PathUtilities.GetDirectoryName(linkPath).Split(PathUtilities.DirectorySeparatorChar, PathUtilities.AltDirectorySeparatorChar)]; 277var folders = relativePath == null ? [] : relativePath.Split([PathUtilities.DirectorySeparatorChar, PathUtilities.AltDirectorySeparatorChar], StringSplitOptions.RemoveEmptyEntries).ToImmutableArray();

Program.cs (1)

33var propertyParts = property.Split(['='], count: 2);

Rpc\Contracts\MonoMSBuildDiscovery.cs (1)

32.Split(Path.PathSeparator)

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

632var pathParts = path.Split(s_pathChars);

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

NewlyCreatedProjectsFromDotNetNew.cs (1)

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

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

Workspaces\TestWorkspace_XmlConsumption.cs (1)

714var 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.Build.Manifest (1)

VersionIdentifier.cs (1)

219string[] pathSegments = assetName.Split('/');

Microsoft.DotNet.Build.Tasks.Packaging (2)

GenerateNuSpec.cs (1)

359string[] packageTypeSplitInPart = packageType.Split(new char[] { ',' });

HarvestPackage.cs (1)

580var parts = path.Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);

Microsoft.DotNet.Build.Tasks.Workloads (2)

WorkloadPackageBase.cs (2)

282if (string.IsNullOrEmpty(version.Prerelease) || version.Prerelease.Split('.').Any(s => string.Equals("ci", s) || string.Equals("dev", s))) 287string[] preleaseParts = version.Prerelease.Split('.');

Microsoft.DotNet.CodeAnalysis (1)

Analyzers\PinvokeAnalyzer.cs (1)

82string[] splitCount = lineStr.Split('!');

Microsoft.DotNet.GenFacades (1)

GenPartialFacadeSourceGenerator.cs (1)

61return defineConstants?.Split(';', ',').Where(t => !string.IsNullOrEmpty(t)).ToArray();

Microsoft.DotNet.NuGetRepack.Tests (1)

TestHelpers\AssertEx.cs (1)

399var inputLines = input.Split('\n', '\r');

Microsoft.DotNet.SignCheckTask (1)

src\SignCheckTask.cs (1)

130string[] filestatuses = FileStatus.Split(';', ',');

Microsoft.DotNet.SignTool (1)

src\SignToolTask.cs (1)

374var directoryParts = Path.GetFullPath(Path.GetDirectoryName(itemToSign.ItemSpec)).Split(separators);

Microsoft.DotNet.SourceBuild.Tasks (1)

src\UsageReport\WriteUsageReports.cs (1)

97string[] segments = line.Split('\\');

Microsoft.Extensions.ApiDescription.Client (1)

MetadataSerializer.cs (1)

94var metadata = value.Split('|');

Microsoft.Extensions.Caching.Hybrid.Tests (1)

PayloadTests.cs (1)

44? TagSet.Empty : TagSet.Create(delimitedTags.Split(','));

Microsoft.Extensions.DependencyModel (1)

Resolution\PackageCompilationAssemblyResolver.cs (1)

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

Microsoft.Extensions.FileProviders.Embedded (1)

EmbeddedFileProvider.cs (1)

289var subNames = name.Split(new[] { '/', '\\' });

Microsoft.Interop.ComInterfaceGenerator (4)

Analyzers\AddMarshalAsToElementFixer.cs (1)

39foreach (var unmanagedType in addMarshalAsAttribute.Split(','))

ComInterfaceGenerator.cs (1)

243string typeName = type.FullTypeName.Split('.', ':')[^1];

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

63foreach (string option in equivalenceKey.Split(';').Skip(0)) 65string[] optionKeyAndValue = option.Split('=');

Microsoft.Interop.LibraryImportGenerator (4)

Analyzers\CustomMarshallerAttributeFixer.cs (2)

52membersToAdd.UnionWith(diagnostic.Properties[MissingMemberNames.Key].Split(MissingMemberNames.Delimiter)); 141missingMemberNames.UnionWith(missingMembers.Split(MissingMemberNames.Delimiter));

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

63foreach (string option in equivalenceKey.Split(';').Skip(0)) 65string[] optionKeyAndValue = option.Split('=');

Microsoft.Interop.SourceGeneration (1)

TypeSymbolExtensions.cs (1)

334string[] typeNameParts = typeName.Split('.');

Microsoft.Maui.Controls (3)

BindingExpression.cs (1)

226 string[] pathParts = p.Split(ExpressionSplit);

Shapes\PointCollectionConverter.cs (1)

28 string[] points = strValue.Split(new char[] { ' ', ',' });

Shell\ShellUriHandler.cs (1)

29 foreach (var p in pathPart.Split(_pathSeparators))

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

CompiledConverters\BindablePropertyConverter.cs (1)

33 var parts = value.Split('.');

CompiledConverters\BoundsTypeConverter.cs (1)

23 var xywh = value.Split(',');

CompiledConverters\ColorTypeConverter.cs (1)

39 var parts = value.Split('.');

CompiledConverters\ColumnDefinitionCollectionTypeConverter.cs (1)

20 var parts = value.Split(',');

CompiledConverters\CornerRadiusTypeConverter.cs (1)

20 var cornerradius = value.Split(',');

CompiledConverters\EasingTypeConverter.cs (1)

21 var parts = value.Split('.');

CompiledConverters\LayoutOptionsConverter.cs (1)

24 var parts = value.Split('.');

CompiledConverters\RectangleTypeConverter.cs (1)

21 var xywh = value.Split(',');

CompiledConverters\RowDefinitionCollectionTypeConverter.cs (1)

20 var parts = value.Split(',');

CompiledConverters\ThicknessTypeConverter.cs (1)

20 var thickness = value.Split(',');

CompiledConverters\TypeTypeConverter.cs (1)

21 var split = value.Split(':');

CreateObjectVisitor.cs (2)

366 var n = node.XmlType.Name.Split(':')[1]; 371 var name = node.XmlType.Name.Split(':')[1];

ExpandMarkupsVisitor.cs (1)

128 var split = match.Split(':');

NodeILExtensions.cs (1)

366 foreach (var v in value.Split(','))

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

BoundsDesignTypeConverter.cs (1)

16 string[] xywh = strValue.Split(',');

CornerRadiusDesignTypeConverter.cs (1)

18 var parts = strValue.Split(',');

DesignTypeConverterHelper.cs (1)

16 string[] parts = numberCollection.Split(separator);

GridLengthCollectionDesignTypeConverter.cs (1)

18 string[] lengths = strValue.Split(',');

Microsoft.Maui.Controls.SourceGen (5)

CodeBehindGenerator.cs (2)

450 var parts = instruction.Data.Split(' ', '='); 691 var plats = platforms.Value.Split(',');

src\Controls\src\Xaml\TypeArgumentsParser.cs (1)

66 var split = type.Split(':');

src\Controls\src\Xaml\XmlnsHelper.cs (2)

38 foreach (var decl in xmlns.Split(';')) 70 foreach (var decl in xmlns.Split(';'))

Microsoft.Maui.Graphics (1)

PathBuilder.cs (1)

68 var split = value.Split(new[] { '.' });

Microsoft.Maui.Graphics.Text.Markdig (1)

Renderer\SimpleCssParser.cs (1)

15 var entries = css.Split(';');

Microsoft.Maui.Resizetizer (4)

GeneratePackageAppxManifest.cs (1)

357 var parts = displayVersion?.Split('.') ?? Array.Empty<string>();

GenerateTizenManifest.cs (1)

212 var parts = displayVersion?.Split('.') ?? Array.Empty<string>();

TizenResourceXmlGenerator.cs (1)

70 var resolution = subDir.Name.Split('-')[1];

TizenSplashUpdater.cs (1)

46 var resolution = dpi.Path.Split('-')[1].ToLowerInvariant();

Microsoft.ML.AutoML.SourceGenerator (1)

Utils.cs (1)

72return string.Join(string.Empty, str.Split('_', ' ', '-').Select(x => CapitalFirstLetter(x)));

Microsoft.ML.Core (4)

CommandLine\ArgumentAttribute.cs (1)

95return _shortName.Split(',').Select(name => name.Trim()).ToArray();

CommandLine\CmdParser.cs (1)

699foreach (string val in value.Split(':'))

Data\ModelLoading.cs (1)

32string[] nameDetails = LoaderAssemblyName.Split(',');

EntryPoints\ModuleArgs.cs (1)

59var parts = value.Split(',');

Microsoft.ML.Data (12)

DataLoadSave\Text\TextLoader.cs (3)

154var rgstr = str.Split(':'); 177var strs = str.Split(','); 1227foreach (string s in sep.Split(','))

Dirty\PredictionUtils.cs (2)

84res.AddRange(arg.Split(';')); 116foreach (string s in sep.Split(','))

Evaluators\RankingEvaluator.cs (1)

85string[] gains = options.LabelGains.Split(',');

Model\Pfa\SavePfaCommand.cs (1)

90return new HashSet<string>(toDrop.Split(','));

Scorers\QuantileRegressionScorer.cs (1)

56Double[] quantilesArray = quantiles.Split(',').Select(

Transforms\ColumnBindingsBase.cs (2)

150Source = src.Split(','); 193Source = src.Split(',');

Transforms\SlotsDroppingTransformer.cs (1)

80var strs = str.Split(',');

Utilities\StreamUtils.cs (1)

70var patterns = pattern.Split('+');

Microsoft.ML.Fairlearn (2)

Reductions\GridSearchTrialRunner.cs (2)

62var sign = x.Split('_')[1] == "pos" ? "+" : "-"; 63var e = x.Split('_')[0];

Microsoft.ML.FastTree (2)

GamModelParameters.cs (1)

472var goodLines = ini.Split(new[] { '\n' }).Where(line => !line.StartsWith("SplitGain="));

TreeEnsemble\InternalTreeEnsemble.cs (1)

203string[] trainingParamsList = trainingParams.Split(new char[] { '\n' });

Microsoft.ML.InternalCodeAnalyzer (1)

ContractsCheckNameofFixProvider.cs (1)

156if (shortName.Split(',').Contains(nameArgValue))

Microsoft.ML.LightGbm (12)

LightGbmMulticlassTrainer.cs (2)

264var split = lines[i].Split(' '); 265_numberOfClassesIncludingNan = int.Parse(split[1].Split(':')[1]);

LightGbmTrainerBase.cs (3)

412var split = lines[i].Split(' '); 413GbmOptions["objective"] = split[0].Split('=')[1]; 453var catBoundaries = !String.IsNullOrEmpty(modelParameters["categorical_feature"]) ? modelParameters["categorical_feature"].Split(',').Select(x => int.Parse(x, CultureInfo.InvariantCulture)).ToArray() : null;

WrappedLightGbmBooster.cs (7)

101foreach (var token in str.Split(delimiter)) 122return str.Split(delimiter).Select(x => int.Parse(x, CultureInfo.InvariantCulture)).ToArray(); 127return str.Split(delimiter).Select(x => UInt32.Parse(x, CultureInfo.InvariantCulture)).ToArray(); 198return int.Parse(lines[i].Split('=')[1]) + 1; 216var param = lines[i].Substring(1, lines[i].Length - 2).Split(':'); 227string[] lines = modelString.Split('\n'); 237string[] kv = lines[i].Split('=');

Microsoft.ML.OnnxConverter (2)

SaveOnnxCommand.cs (2)

111_inputsToDrop = CreateDropMap(args.InputsToDropArray ?? args.InputsToDrop?.Split(',')); 112_outputsToDrop = CreateDropMap(args.OutputsToDropArray ?? args.OutputsToDrop?.Split(','));

Microsoft.ML.Parquet (1)

PartitionedPathParser.cs (1)

378var nameValue = dir.Split(nameValueSeparator);

Microsoft.ML.PerformanceTests (1)

HashBench.cs (1)

199var tokens = "Hello my friend, stay awhile and listen! ".Split().Select(token => token.AsMemory()).ToArray();

Microsoft.ML.ResultProcessor (3)

ResultProcessor.cs (3)

964string[] foldLineCols = lines[0].Split(); 990string[] nameValCols = lines[i].Split(':'); 1062m.AddRange(metric.Split(new char[] { ';', ',' }));

Microsoft.ML.StandardTrainers (1)

Standard\Online\OnlineLinear.cs (1)

147string[] weightStr = parent.OnlineLinearTrainerOptions.InitialWeights.Split(',');

Microsoft.ML.Sweeper (2)

Parameters.cs (2)

531generatorOptions.Values = paramValue.Split(','); 578string[] options = scaleStr.Split(';');

Microsoft.ML.TimeSeries (1)

MovingAverageTransform.cs (1)

75_weights = string.IsNullOrWhiteSpace(args.Weights) ? null : args.Weights.Split(',').Select(c => Convert.ToSingle(c)).ToArray();

Microsoft.ML.TorchSharp (3)

AutoFormerV2\ObjectDetectionTrainer.cs (1)

262var destFileName = ModelUrl.Split('/').Last();

Roberta\QATrainer.cs (1)

246var destFileName = ModelUrl.Split('/').Last();

TorchSharpBaseTrainer.cs (1)

172var destFileName = modelUrl.Split('/').Last();

Microsoft.ML.Transforms (4)

LoadTransform.cs (1)

84foreach (var tag in curList.Split(','))

Text\WordBagTransform.cs (2)

312foreach (var termFreq in inputText.Split(_parent._termSeparator)) 314var tf = termFreq.Split(_parent._freqSeparator);

Text\WordEmbeddingsExtractor.cs (1)

707string[] wordsInFirstLine = firstLine.TrimEnd().Split(' ', '\t');

Microsoft.ML.Vision (5)

ImageClassificationTrainer.cs (5)

733if (_session.graph.OperationByName(_labelTensor.name.Split(':')[0]) == null) 1208sess, graph.as_graph_def(), new string[] { _softMaxTensor.name.Split(':')[0], 1209_prediction.name.Split(':')[0], _jpegData.name.Split(':')[0], _resizedImage.name.Split(':')[0] });

Microsoft.VisualStudio.LanguageServices (11)

Diagnostics\VisualStudioDiagnosticAnalyzerProvider.Factory.cs (1)

48var vsDteVersion = Version.Parse(dte.Version.Split(' ')[0]); // DTE.Version is in the format of D[D[.D[D]]][ (?+)], so we need to split out the version part and check for uninitialized Major/Minor below

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

MoveStaticMembers\MoveStaticMembersDialogViewModel.cs (1)

121foreach (var identifier in typeName.Split('.'))

MoveStaticMembers\TypeNameItem.cs (2)

51var xnames = x.FullyQualifiedTypeName.Split('.'); 52var ynames = y.FullyQualifiedTypeName.Split('.');

MoveStaticMembers\VisualStudioMoveStaticMembersOptionsService.cs (1)

64var typeName = viewModel.DestinationName.FullyQualifiedTypeName.Split('.').Last();

MoveToNamespace\MoveToNamespaceDialogViewModel.cs (1)

82foreach (var identifier in namespaceName.Split('.'))

Preview\FileChange.cs (1)

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

Venus\ContainedLanguageCodeSupport.cs (1)

429var parts = fullyQualifiedName.Split('.');

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)

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

ProjectSystemShim\TempPECompilerService.cs (1)

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

Microsoft.VisualStudio.LanguageServices.LiveShare (1)

Client\RemoteLanguageServiceWorkspace.cs (1)

179var splitRoot = localRoot.TrimEnd('\\').Split('\\');

MSBuild (4)

XMake.cs (4)

2888foreach (string parameter in s.Split(MSBuildConstants.SemicolonChar)) 2895string[] parameterAndValue = parameter.Split(MSBuildConstants.EqualsChar); 4173string[] nameValues = parameters.Split(MSBuildConstants.SemicolonChar); 4203string[] nameValuePair = parameter.Split(MSBuildConstants.EqualsChar);

PresentationBuildTasks (1)

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

807foreach (string sdk in sdks.Split(s_semicolonChar).Select(i => i.Trim()))

PresentationFramework (4)

System\Windows\Application.cs (2)

2364string[] bamlConvertUriSegments = fileInBamlConvert.Split(new Char[] { '/', '\\' }); 2365string[] curUriSegments = fileCurrent.Split(new Char[] { '/', '\\' });

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

227string[] tokens = findPattern.Split(null);

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

424string[] pieces = attrValue.Split(new char[] { ' ', '}' });

Roslyn.Compilers.Extension (2)

CompilerPackage.cs (2)

41var registryParts = localRegistryRoot.Split('\\'); 152var parts = dte.Version.Split('.');

Roslyn.Diagnostics.Analyzers (3)

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

45var guids = propertyValue.Split(';').Select(g => g.Trim()).ToImmutableArray();

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

162foreach (var kindStr in value.Split(','))

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

210foreach (var commentPart in comment.Split('\r', '\n'))

Roslyn.Diagnostics.CSharp.Analyzers (1)

NumberCommentsRefactoring.cs (1)

93var numbers = separatedNumbers.Split(',').Select(removeWhiteSpace);

Roslyn.VisualStudio.DiagnosticsWindow (1)

PerfMargin\DataModel.cs (1)

34var featureNames = name.Split('_');

Roslyn.VisualStudio.Next.UnitTests (3)

Services\PerformanceTrackerServiceTests.cs (3)

191var lines = testFile.Split('\n'); 201var data = SkipAnalyzerId(lines[i]).Split(','); 232var data = header.Split(',');

RulesetToEditorconfigConverter (1)

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

210foreach (var commentPart in comment.Split('\r', '\n'))

SemanticSearch.BuildTask (1)

GenerateFilteredReferenceAssembliesTask.cs (1)

274=> new("^" + string.Join(".*", pattern.Trim().Split('*').Select(Regex.Escape)) + "$",

System.CodeDom (2)

Microsoft\CSharp\CSharpCodeGenerator.cs (1)

2399string[] names = e.Name.Split(s_periodArray);

Microsoft\VisualBasic\VBCodeGenerator.cs (1)

2325string[] names = e.Name.Split(s_periodArray);

System.Configuration.ConfigurationManager (6)

System\Configuration\BaseConfigurationRecord.cs (1)

1216string[] keys = configKey.Split(s_configPathSeparatorParams);

System\Configuration\ConfigurationElement.cs (1)

1302string[] attribsToLock = attributeList.Split(',', ':', ';');

System\Configuration\ConfigurationLockCollection.cs (1)

331string[] splits = attributeList.Split(',', ';', ':');

System\Configuration\MgmtConfigurationRecord.cs (1)

435string[] keys = configKey.Split(s_configPathSeparatorParams);

System\Configuration\SectionUpdates.cs (1)

42string[] groups = group.Split(BaseConfigurationRecord.s_configPathSeparatorParams);

System\Configuration\StringAttributeCollection.cs (1)

42string[] items = list.Split(delimiters);

System.Data.Common (4)

System\Data\XDRSchema.cs (1)

591string[] list = keys.TrimEnd(null).Split(null);

System\Data\XMLSchema.cs (3)

463parentNames = value.TrimEnd(null).Split(new char[] { Keywords.MSD_KEYFIELDSEP, Keywords.MSD_KEYFIELDOLDSEP }); 468childNames = value.TrimEnd(null).Split(new char[] { Keywords.MSD_KEYFIELDSEP, Keywords.MSD_KEYFIELDOLDSEP }); 2797string[] split = xpath.Split('/', ':');

System.Data.Odbc (1)

System\Data\Odbc\OdbcMetaDataFactory.cs (1)

989string[] values = keywords.Split(KeywordSeparatorChar);

System.IO.Packaging (1)

System\IO\Packaging\PackUriHelper.cs (1)

778string[] segments = NormalizedPartUriString.Split(s_forwardSlashCharArray); //new Uri(_defaultUri, this).Segments; //partUri.Segments cannot be called on a relative Uri;

System.Net.Requests (1)

System\Net\FtpControlStream.cs (1)

1057string[] parsedList = responseString.Split(s_spaceCommaBrackets);

System.Net.WebClient (1)

System\Net\WebClient.cs (1)

1108string[] parsedList = contentType.Split(s_parseContentTypeSeparators);

System.Private.CoreLib (1)

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

5002/// <see cref="string.Split(char[])"/> and related overloads are used with an empty separator array,

System.Private.CoreLib.Generators (2)

ProductVersionInfoGenerator.cs (2)

21string? productVersion = informationalVersion?.Split('+')?[0]; 27string environmentVersion = Version.Parse(productVersion.Split('-')[0]).ToString();

System.Private.Windows.Core.TestUtilities (1)

DebuggerAttributes.cs (1)

131string[] segments = attrText.Split(['{', '}']);

System.Private.Xml (6)

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

284string[] names = identifier.Split(s_identifierSeparators);

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

1987string[] vals = listValues.Split(null);

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

457string[] parts = val.Split(null);

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

1047dimensions = arraySize.Split(null);

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

2468string[] values = ((string)defaultValue!).Split(null);

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

208string[] values = ((string)defaultValue!).Split(null);

System.Security.Cryptography.Xml (1)

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

395string[] prefixes = s.Split(null);

System.Web.Services.Description (3)

System\Web\Services\Description\ServiceDescription.cs (1)

858ParameterOrder = value.Split(new char[] { ' ' });

System\Web\Services\Description\ServiceDescriptionSerializer.cs (1)

9283string[] vals = listValues.Split(null);

System\Web\Services\Description\SoapFormatExtensions.cs (1)

117Parts = value.Split(new char[] { ' ' });

System.Windows.Controls.Ribbon (1)

Microsoft\Windows\Controls\Ribbon\RibbonTwoLineText.cs (1)

388int wordCount = string.IsNullOrEmpty(Text) ? 0 : Text.Split().Length;

System.Windows.Forms.Analyzers.CSharp (1)

System\Windows\Forms\CSharp\Generators\ApplicationConfiguration\ProjectFileReader.FontConverter.cs (1)

97string[] styleTokens = style.Split(separator);

System.Windows.Forms.Design (1)

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

2496string[] exceptionLines = exception.StackTrace.Split('\r', '\n');

TaskUsageLogger (2)

TaskUsageLogger.cs (2)

91string[] parameters = Parameters.Split(s_semicolonChar); 386string[] parts = name2.Split(s_fullyQualifiedTaskNameSeperators);

Test.Utilities (1)

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

210foreach (var commentPart in comment.Split('\r', '\n'))

Text.Analyzers (3)

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

45var guids = propertyValue.Split(';').Select(g => g.Trim()).ToImmutableArray();

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

162foreach (var kindStr in value.Split(','))

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

210foreach (var commentPart in comment.Split('\r', '\n'))

VisualBasicSyntaxGenerator (1)

Util\XmlRenamer.vb (1)

44Dim fields = line.Split({","c})

XmlFileLogger (2)

ItemGroupParser.cs (1)

25var lines = message.Split('\n');

XmlFileLogger.cs (1)

163string[] parameters = Parameters.Split(';');