String.Join Método

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Concatena os elementos de uma matriz especificada ou os membros de uma coleção, usando o separador especificado entre cada elemento ou membro.

Sobrecargas

Join(Char, Object[])	Concatena as representações de cadeia de caracteres de uma matriz de objetos, usando o separador especificado entre cada membro.
Join(Char, String[])	Concatena as matrizes de cadeias de caracteres, usando o separador especificado entre cada membro.
Join(String, IEnumerable<String>)	Concatena os membros de uma coleção de IEnumerable<T> construída do tipo String, usando o separador especificado entre cada membro.
Join(String, Object[])	Concatena os elementos de uma matriz de objetos, usando o separador especificado entre cada elemento.
Join(String, String[])	Concatena todos os elementos de uma matriz de cadeia de caracteres usando o separador especificado entre cada elemento.
Join(Char, String[], Int32, Int32)	Concatena uma matriz de cadeias de caracteres, usando o separador especificado entre cada membro, começando com o elemento em `value` localizado na posição `startIndex` e concatenando até os elementos `count`.
Join(String, String[], Int32, Int32)	Concatena os elementos especificados de uma matriz de cadeia de caracteres usando o separador especificado entre cada elemento.
Join<T>(String, IEnumerable<T>)	Concatena os membros de uma coleção, usando o separador especificado entre cada membro.
Join<T>(Char, IEnumerable<T>)	Concatena os membros de uma coleção, usando o separador especificado entre cada membro.

Join(Char, Object[])

Concatena as representações de cadeia de caracteres de uma matriz de objetos, usando o separador especificado entre cada membro.

public:
 static System::String ^ Join(char separator, ... cli::array <System::Object ^> ^ values);

public static string Join (char separator, params object?[] values);

public static string Join (char separator, params object[] values);

static member Join : char * obj[] -> string

Public Shared Function Join (separator As Char, ParamArray values As Object()) As String

Parâmetros

separator: Char

O caractere a ser usado como um separador. separator estará incluído na cadeia de caracteres retornada somente se value tiver mais de um elemento.

values: Object[]

Uma matriz de objetos cujas representações de cadeia de caracteres serão concatenadas.

Retornos

String

Uma cadeia de caracteres composta pelos elementos de values delimitados pelo caractere separator.

- ou -

Empty se values não tiver elementos.

Exceções

ArgumentNullException

value é null.

OutOfMemoryException

O comprimento da cadeia de caracteres resultante estoura o comprimento máximo permitido (Int32.MaxValue).

Aplica-se a

Join(Char, String[])

Concatena as matrizes de cadeias de caracteres, usando o separador especificado entre cada membro.

public:
 static System::String ^ Join(char separator, ... cli::array <System::String ^> ^ value);

public static string Join (char separator, params string?[] value);

public static string Join (char separator, params string[] value);

static member Join : char * string[] -> string

Public Shared Function Join (separator As Char, ParamArray value As String()) As String

Parâmetros

separator: Char

O caractere a ser usado como um separador. separator estará incluído na cadeia de caracteres retornada somente se value tiver mais de um elemento.

value: String[]

Uma matriz de cadeias de caracteres para concatenar.

Retornos

String

Uma cadeia de caracteres composta pelos elementos de value delimitados pelo caractere separator.

- ou -

Empty se value não tiver elementos.

Exceções

ArgumentNullException

value é null.

OutOfMemoryException

O comprimento da cadeia de caracteres resultante estoura o comprimento máximo permitido (Int32.MaxValue).

Aplica-se a

Join(String, IEnumerable<String>)

Concatena os membros de uma coleção de IEnumerable<T> construída do tipo String, usando o separador especificado entre cada membro.

public:
 static System::String ^ Join(System::String ^ separator, System::Collections::Generic::IEnumerable<System::String ^> ^ values);

public static string Join (string separator, System.Collections.Generic.IEnumerable<string> values);

public static string Join (string? separator, System.Collections.Generic.IEnumerable<string?> values);

[System.Runtime.InteropServices.ComVisible(false)]
public static string Join (string separator, System.Collections.Generic.IEnumerable<string> values);

static member Join : string * seq<string> -> string

[<System.Runtime.InteropServices.ComVisible(false)>]
static member Join : string * seq<string> -> string

Public Shared Function Join (separator As String, values As IEnumerable(Of String)) As String

Parâmetros

separator: String

A cadeia de caracteres a ser usada como um separador.separator estará incluído na cadeia de caracteres retornada somente se values tiver mais de um elemento.

values: IEnumerable<String>

Uma coleção que contém as cadeias de caracteres a serem concatenadas.

Retornos

String

Uma cadeia de caracteres composta pelos elementos de values delimitados pela cadeia de caracteres separator.

-ou-

Empty se values não tiver elementos.

Atributos: ComVisibleAttribute

Exceções

ArgumentNullException

values é null.

OutOfMemoryException

O comprimento da cadeia de caracteres resultante estoura o comprimento máximo permitido (Int32.MaxValue).

Exemplos

O exemplo a seguir usa o algoritmo Sieve of Eratosthenes para calcular os números principais menores que ou iguais a 100. Ele atribui o resultado a um List<T> objeto do tipo String, que, em seguida, passa para o Join(String, IEnumerable<String>) método .

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      int maxPrime = 100;
      List<int> primes = GetPrimes(maxPrime);
      Console.WriteLine("Primes less than {0}:", maxPrime);
      Console.WriteLine("   {0}", String.Join(" ", primes));
   }

   private static List<int> GetPrimes(int maxPrime)
   {
      Array values = Array.CreateInstance(typeof(int), 
                              new int[] { maxPrime - 1}, new int[] { 2 });
      // Use Sieve of Eratosthenes to determine prime numbers.
      for (int ctr = values.GetLowerBound(0); ctr <= (int) Math.Ceiling(Math.Sqrt(values.GetUpperBound(0))); ctr++)
      {
                           
         if ((int) values.GetValue(ctr) == 1) continue;
         
         for (int multiplier = ctr; multiplier <=  maxPrime / 2; multiplier++)
            if (ctr * multiplier <= maxPrime)
               values.SetValue(1, ctr * multiplier);
      }      
      
      List<int> primes = new List<int>();
      for (int ctr = values.GetLowerBound(0); ctr <= values.GetUpperBound(0); ctr++)
         if ((int) values.GetValue(ctr) == 0) 
            primes.Add(ctr);
      return primes;
   }   
}
// The example displays the following output:
//    Primes less than 100:
//       2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

open System

let getPrimes maxPrime =
    let values = Array.CreateInstance(typeof<int>, [| maxPrime - 1 |], [| 2 |])
    // Use Sieve of Eratosthenes to determine prime numbers.
    for i = values.GetLowerBound 0 to values.GetUpperBound 0 |> float |> sqrt |> ceil |> int do
        if values.GetValue i :?> int <> 1 then
            for multiplier = i to maxPrime / 2 do
                if i * multiplier <= maxPrime then
                    values.SetValue(1, i * multiplier)

    let primes = ResizeArray()
    for i = values.GetLowerBound 0 to values.GetUpperBound 0 do
        if values.GetValue i :?> int = 0 then
            primes.Add i
    primes

let maxPrime = 100
let primes = getPrimes maxPrime
printfn $"Primes less than {maxPrime}:"
printfn $"""   {String.Join(" ", primes)}"""

// The example displays the following output:
//    Primes less than 100:
//       2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim maxPrime As Integer = 100
      Dim primes As List(Of String) = GetPrimes(maxPrime)
      Console.WriteLine("Primes less than {0}:", maxPrime)
      Console.WriteLine("   {0}", String.Join(" ", primes))
   End Sub
   
   Private Function GetPrimes(maxPrime As Integer) As List(Of String)
      Dim values As Array = Array.CreateInstance(GetType(Integer), _
                              New Integer() { maxPrime - 1}, New Integer(){ 2 }) 
        ' Use Sieve of Eratosthenes to determine prime numbers.
      For ctr As Integer = values.GetLowerBound(0) To _
                           CInt(Math.Ceiling(Math.Sqrt(values.GetUpperBound(0))))
         If CInt(values.GetValue(ctr)) = 1 Then Continue For
         
         For multiplier As Integer = ctr To maxPrime \ 2
            If ctr * multiplier <= maxPrime Then values.SetValue(1, ctr * multiplier)
         Next   
      Next      
      
      Dim primes As New List(Of String)
      For ctr As Integer = values.GetLowerBound(0) To values.GetUpperBound(0)
         If CInt(values.GetValue(ctr)) = 0 Then primes.Add(ctr.ToString())
      Next            
      Return primes
   End Function   
End Module
' The example displays the following output:
'    Primes less than 100:
'       2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

Comentários

Caso separator seja null, uma cadeia de caracteres vazia (String.Empty) é usada em seu lugar. Se qualquer membro de for null, uma cadeia de values caracteres vazia será usada.

Join(String, IEnumerable<String>) é um método de conveniência que permite concatenar cada elemento em uma IEnumerable(Of String) coleção sem primeiro converter os elementos em uma matriz de cadeia de caracteres. Ele é particularmente útil com expressões de consulta LINQ (consulta Language-Integrated). O exemplo a seguir passa um List(Of String) objeto que contém as letras maiúsculas ou minúsculas do alfabeto para uma expressão lambda que seleciona letras iguais ou maiores que uma letra específica (que, no exemplo, é "M"). A IEnumerable(Of String) coleção retornada pelo Enumerable.Where método é passada para o Join(String, IEnumerable<String>) método para exibir o resultado como uma única cadeia de caracteres.

using System;
using System.Collections.Generic;
using System.Linq;

public class Example
{
   public static void Main()
   {
      string output = String.Join(" ", GetAlphabet(true).Where( letter => 
                      letter.CompareTo("M") >= 0));
      Console.WriteLine(output);  
   }

   private static List<string> GetAlphabet(bool upper)
   {
      List<string> alphabet = new List<string>();
      int charValue = upper ? 65 : 97;
      for (int ctr = 0; ctr <= 25; ctr++)
         alphabet.Add(((char)(charValue + ctr)).ToString());
      return alphabet; 
   }
}
// The example displays the following output:
//      M N O P Q R S T U V W X Y Z

// This F# example uses Seq.filter instead of Linq.
open System

let getAlphabet upper =
    let charValue = if upper then 65 else 97
    seq {
        for i = 0 to 25 do
            charValue + i
            |> char
            |> string
    }

String.Join(" ", getAlphabet true |> Seq.filter (fun letter -> letter.CompareTo "M" >= 0))
|> printfn "%s"

// The example displays the following output:
//      M N O P Q R S T U V W X Y Z

Imports System.Collections.Generic
Imports System.Linq

Module modMain
   Public Sub Main()
      Dim output As String = String.Join(" ", GetAlphabet(True).Where(Function(letter) _
                                                         letter >= "M"))
        
      Console.WriteLine(output)                                     
   End Sub
   
   Private Function GetAlphabet(upper As Boolean) As List(Of String)
      Dim alphabet As New List(Of String)
      Dim charValue As Integer = CInt(IIf(upper, 65, 97))
      For ctr As Integer = 0 To 25
         alphabet.Add(ChrW(charValue + ctr).ToString())
      Next
      Return alphabet 
   End Function
End Module
' The example displays the following output:
'      M N O P Q R S T U V W X Y Z

Confira também

Split(Char[])

Aplica-se a

Join(String, Object[])

Concatena os elementos de uma matriz de objetos, usando o separador especificado entre cada elemento.

public:
 static System::String ^ Join(System::String ^ separator, ... cli::array <System::Object ^> ^ values);

public static string Join (string separator, params object[] values);

public static string Join (string? separator, params object?[] values);

[System.Runtime.InteropServices.ComVisible(false)]
public static string Join (string separator, params object[] values);

static member Join : string * obj[] -> string

[<System.Runtime.InteropServices.ComVisible(false)>]
static member Join : string * obj[] -> string

Public Shared Function Join (separator As String, ParamArray values As Object()) As String

Parâmetros

separator: String

A cadeia de caracteres a ser usada como um separador. separator estará incluído na cadeia de caracteres retornada somente se values tiver mais de um elemento.

values: Object[]

Uma matriz que contém os elementos a concatenar.

Retornos

String

Uma cadeia de caracteres composta pelos elementos de values delimitados pela cadeia de caracteres separator.

-ou-

Empty se values não tiver elementos.

-ou-

.NET Framework somente: Empty se o primeiro elemento de values for null.

Atributos: ComVisibleAttribute

Exceções

ArgumentNullException

values é null.

OutOfMemoryException

O comprimento da cadeia de caracteres resultante estoura o comprimento máximo permitido (Int32.MaxValue).

Exemplos

O exemplo a seguir usa o algoritmo Sieve of Eratosthenes para calcular os números principais menores que ou iguais a 100. Ele atribui o resultado a uma matriz de inteiros, que, em seguida, passa para o Join(String, Object[]) método .

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      int maxPrime = 100;
      int[] primes = GetPrimes(maxPrime);
      Console.WriteLine("Primes less than {0}:", maxPrime);
      Console.WriteLine("   {0}", String.Join(" ", primes));
   }

   private static int[] GetPrimes(int maxPrime)
   {
      Array values = Array.CreateInstance(typeof(int), 
                              new int[] { maxPrime - 1}, new int[] { 2 }); 
      // Use Sieve of Eratosthenes to determine prime numbers.
      for (int ctr = values.GetLowerBound(0); ctr <= (int) Math.Ceiling(Math.Sqrt(values.GetUpperBound(0))); ctr++)
      {
                           
         if ((int) values.GetValue(ctr) == 1) continue;
         
         for (int multiplier = ctr; multiplier <=  maxPrime / 2; multiplier++)
            if (ctr * multiplier <= maxPrime)
               values.SetValue(1, ctr * multiplier);
      }      
      
      List<int> primes = new List<int>();
      for (int ctr = values.GetLowerBound(0); ctr <= values.GetUpperBound(0); ctr++)
         if ((int) values.GetValue(ctr) == 0) 
            primes.Add(ctr);
      return primes.ToArray();
   }   
}
// The example displays the following output:
//    Primes less than 100:
//       2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

open System

let getPrimes maxPrime =
    let values = Array.CreateInstance(typeof<int>, [| maxPrime - 1 |], [| 2 |])
    // Use Sieve of Eratosthenes to determine prime numbers.
    for i = values.GetLowerBound 0 to values.GetUpperBound 0 |> float |> sqrt |> ceil |> int do
        if values.GetValue i :?> int <> 1 then
            for multiplier = i to maxPrime / 2 do
                if i * multiplier <= maxPrime then
                    values.SetValue(1, i * multiplier)

    [| for i = values.GetLowerBound 0 to values.GetUpperBound 0 do
        if values.GetValue i :?> int = 0 then
            i |]

let maxPrime = 100
let primes = getPrimes maxPrime
printfn $"Primes less than {maxPrime}:"
printfn $"""   {String.Join(" ", primes)}"""

// The example displays the following output:
//    Primes less than 100:
//       2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

Module Example
   Public Sub Main()
      Dim maxPrime As Integer = 100
      Dim primes() As Integer = GetPrimes(maxPrime)
      Console.WriteLine("Primes less than {0}:", maxPrime)
      Console.WriteLine("   {0}", String.Join(" ", primes))
   End Sub
   
   Private Function GetPrimes(maxPrime As Integer) As Integer()
      Dim values As Array = Array.CreateInstance(GetType(Integer), _
                              New Integer() { maxPrime - 1}, New Integer(){ 2 }) 
        ' Use Sieve of Eratosthenes to determine prime numbers.
      For ctr As Integer = values.GetLowerBound(0) To _
                           CInt(Math.Ceiling(Math.Sqrt(values.GetUpperBound(0))))
         If CInt(values.GetValue(ctr)) = 1 Then Continue For
         
         For multiplier As Integer = ctr To maxPrime \ 2
            If ctr * multiplier <= maxPrime Then values.SetValue(1, ctr * multiplier)
         Next   
      Next      
      
      Dim primes As New System.Collections.Generic.List(Of Integer)
      For ctr As Integer = values.GetLowerBound(0) To values.GetUpperBound(0)
         If CInt(values.GetValue(ctr)) = 0 Then primes.Add(ctr)
      Next            
      Return primes.ToArray()
   End Function   
End Module
' The example displays the following output:
'    Primes less than 100:
'       2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

Comentários

Se separator for null ou se qualquer elemento diferente do values primeiro elemento for null, uma cadeia de caracteres vazia (String.Empty) será usada. Consulte a seção Observações para Chamadores se o primeiro elemento de values for null.

Join(String, Object[]) é um método de conveniência que permite concatenar cada elemento em uma matriz de objetos sem converter explicitamente seus elementos em cadeias de caracteres. A representação de cadeia de caracteres de cada objeto na matriz é derivada chamando o método desse ToString objeto.

Notas aos Chamadores

.NET Framework apenas: se o primeiro elemento de values for , o Join(String, Object[]) método não concatenará os elementos em values , mas retornará Emptynull. Várias soluções alternativas para esse problema estão disponíveis. O mais fácil é atribuir um valor de Empty ao primeiro elemento da matriz, como mostra o exemplo a seguir.

object[] values = { null, "Cobb", 4189, 11434, .366 };
if (values[0] == null) values[0] = String.Empty;
Console.WriteLine(String.Join("|", values));

// The example displays the following output:
//      |Cobb|4189|11434|0.366

let values: obj[] = [| null; "Cobb"; 4189; 11434; 0.366 |]
if values[0] = null then 
   values[0] <- String.Empty
printfn $"""{String.Join("|", values)}"""

// The example displays the following output:
//      |Cobb|4189|11434|0.366

Dim values() As Object = { Nothing, "Cobb", 4189, 11434, .366 }
If values(0) Is Nothing Then values(0) = String.Empty
Console.WriteLine(String.Join("|", values))
' The example displays the following output:
'      |Cobb|4189|11434|0.366

Confira também

Split(Char[])

Aplica-se a

Join(String, String[])

Concatena todos os elementos de uma matriz de cadeia de caracteres usando o separador especificado entre cada elemento.

public:
 static System::String ^ Join(System::String ^ separator, ... cli::array <System::String ^> ^ value);

public:
 static System::String ^ Join(System::String ^ separator, cli::array <System::String ^> ^ value);

public static string Join (string separator, params string[] value);

public static string Join (string? separator, params string?[] value);

public static string Join (string separator, string[] value);

static member Join : string * string[] -> string

Public Shared Function Join (separator As String, ParamArray value As String()) As String

Public Shared Function Join (separator As String, value As String()) As String

Parâmetros

separator: String

A cadeia de caracteres a ser usada como um separador. separator estará incluído na cadeia de caracteres retornada somente se value tiver mais de um elemento.

value: String[]

Uma matriz que contém os elementos a concatenar.

Retornos

String

Uma cadeia de caracteres que consiste nos elementos em value delimitados pela cadeia de caracteres separator.

-ou-

Empty se values não tiver elementos.

Exceções

ArgumentNullException

value é null.

OutOfMemoryException

O comprimento da cadeia de caracteres resultante estoura o comprimento máximo permitido (Int32.MaxValue).

Exemplos

O exemplo a seguir demonstra o Join método.

using namespace System;
String^ MakeLine( int initVal, int multVal, String^ sep )
{
   array<String^>^sArr = gcnew array<String^>(10);
   for ( int i = initVal; i < initVal + 10; i++ )
      sArr[ i - initVal ] = String::Format( "{0, -3}", i * multVal );
   return String::Join( sep, sArr );
}

int main()
{
   Console::WriteLine( MakeLine( 0, 5, ", " ) );
   Console::WriteLine( MakeLine( 1, 6, "  " ) );
   Console::WriteLine( MakeLine( 9, 9, ": " ) );
   Console::WriteLine( MakeLine( 4, 7, "< " ) );
}
// The example displays the following output:
//       0  , 5  , 10 , 15 , 20 , 25 , 30 , 35 , 40 , 45
//       6    12   18   24   30   36   42   48   54   60
//       81 : 90 : 99 : 108: 117: 126: 135: 144: 153: 162
//       28 < 35 < 42 < 49 < 56 < 63 < 70 < 77 < 84 < 91

using System;

public class JoinTest
{
    public static void Main()
    {
        Console.WriteLine(MakeLine(0, 5, ", "));
        Console.WriteLine(MakeLine(1, 6, "  "));
        Console.WriteLine(MakeLine(9, 9, ": "));
        Console.WriteLine(MakeLine(4, 7, "< "));
    }

    private static string MakeLine(int initVal, int multVal, string sep)
    {
        string [] sArr = new string [10];

        for (int i = initVal; i < initVal + 10; i++)
            sArr[i - initVal] = String.Format("{0,-3}", i * multVal);

        return String.Join(sep, sArr);
    }
}
// The example displays the following output:
//       0  , 5  , 10 , 15 , 20 , 25 , 30 , 35 , 40 , 45
//       6    12   18   24   30   36   42   48   54   60
//       81 : 90 : 99 : 108: 117: 126: 135: 144: 153: 162
//       28 < 35 < 42 < 49 < 56 < 63 < 70 < 77 < 84 < 91

open System

let makeLine initVal multVal (sep: string) =
    let sArr = Array.zeroCreate<string> 10 

    for i = initVal to initVal + 9 do
        sArr[i - initVal] <- String.Format("{0,-3}", i * multVal)

    String.Join(sep, sArr)

printfn $"""{makeLine 0 5 ", "}"""
printfn $"""{makeLine 1 6 "  "}"""
printfn $"""{makeLine 9 9 ": "}"""
printfn $"""{makeLine 4 7 "< "}"""

// The example displays the following output:
//       0  , 5  , 10 , 15 , 20 , 25 , 30 , 35 , 40 , 45
//       6    12   18   24   30   36   42   48   54   60
//       81 : 90 : 99 : 108: 117: 126: 135: 144: 153: 162
//       28 < 35 < 42 < 49 < 56 < 63 < 70 < 77 < 84 < 91

Public Class JoinTest
    
    Public Shared Sub Main()
        
        Console.WriteLine(MakeLine(0, 5, ", "))
        Console.WriteLine(MakeLine(1, 6, "  "))
        Console.WriteLine(MakeLine(9, 9, ": "))
        Console.WriteLine(MakeLine(4, 7, "< "))
    End Sub
    
    
    Private Shared Function MakeLine(initVal As Integer, multVal As Integer, sep As String) As String
        Dim sArr(10) As String
        Dim i As Integer
        
        
        For i = initVal To (initVal + 10) - 1
            sArr((i - initVal)) = [String].Format("{0,-3}", i * multVal)
        
        Next i
        Return [String].Join(sep, sArr)
    End Function 'MakeLine
End Class
' The example displays the following output:
'       0  , 5  , 10 , 15 , 20 , 25 , 30 , 35 , 40 , 45
'       6    12   18   24   30   36   42   48   54   60
'       81 : 90 : 99 : 108: 117: 126: 135: 144: 153: 162
'       28 < 35 < 42 < 49 < 56 < 63 < 70 < 77 < 84 < 91

Comentários

Por exemplo, se separator for ", " e os elementos de value forem "maçã", "laranja", "uva" e "pera", Join(separator, value) retornará "maçã, laranja, uva, pera".

Caso separator seja null, uma cadeia de caracteres vazia (String.Empty) é usada em seu lugar. Se qualquer elemento em value for null, uma cadeia de caracteres vazia será usada.

Confira também

Concat(Object)

Aplica-se a

Join(Char, String[], Int32, Int32)

Concatena uma matriz de cadeias de caracteres, usando o separador especificado entre cada membro, começando com o elemento em value localizado na posição startIndex e concatenando até os elementos count.

public:
 static System::String ^ Join(char separator, cli::array <System::String ^> ^ value, int startIndex, int count);

public static string Join (char separator, string?[] value, int startIndex, int count);

public static string Join (char separator, string[] value, int startIndex, int count);

static member Join : char * string[] * int * int -> string

Public Shared Function Join (separator As Char, value As String(), startIndex As Integer, count As Integer) As String

Parâmetros

separator: Char

Concatena uma matriz de cadeias de caracteres, usando o separador especificado entre cada membro, começando com o elemento localizado no índice especificado e incluindo um número especificado de elementos.

value: String[]

Uma matriz de cadeias de caracteres para concatenar.

startIndex: Int32

O primeiro item em value a ser concatenado.

count: Int32

O número de elementos de value para concatenar, começando com o elemento na posição de startIndex.

Retornos

String

Uma cadeia de count caracteres que consiste em elementos de value começando em startIndex delimitado pelo separator caractere .

-ou-

Empty se count for zero.

Exceções

ArgumentNullException

value é null.

ArgumentOutOfRangeException

startIndex ou count é negativo.

- ou -

startIndex é maior que o comprimento de value - count.

OutOfMemoryException

O comprimento da cadeia de caracteres resultante estoura o comprimento máximo permitido (Int32.MaxValue).

Aplica-se a

Join(String, String[], Int32, Int32)

Concatena os elementos especificados de uma matriz de cadeia de caracteres usando o separador especificado entre cada elemento.

public:
 static System::String ^ Join(System::String ^ separator, cli::array <System::String ^> ^ value, int startIndex, int count);

public static string Join (string separator, string[] value, int startIndex, int count);

public static string Join (string? separator, string?[] value, int startIndex, int count);

static member Join : string * string[] * int * int -> string

Public Shared Function Join (separator As String, value As String(), startIndex As Integer, count As Integer) As String

Parâmetros

separator: String

A cadeia de caracteres a ser usada como um separador. separator estará incluído na cadeia de caracteres retornada somente se value tiver mais de um elemento.

value: String[]

Uma matriz que contém os elementos a concatenar.

startIndex: Int32

O primeiro elemento em value a ser usado.

count: Int32

O número de elementos de value a ser usado.

Retornos

String

Uma cadeia de count caracteres que consiste em elementos de value começando em startIndex delimitado pelo separator caractere .

-ou-

Empty se count for zero.

Exceções

ArgumentNullException

value é null.

ArgumentOutOfRangeException

startIndex ou count é menor que 0.

- ou -

startIndex mais count é maior que o número de elementos em value.

OutOfMemoryException

Sem memória.

Exemplos

O exemplo a seguir concatena dois elementos de uma matriz de nomes de frutas.

// Sample for String::Join(String, String[], int int)
using namespace System;
int main()
{
   array<String^>^val = {"apple","orange","grape","pear"};
   String^ sep = ", ";
   String^ result;
   Console::WriteLine( "sep = '{0}'", sep );
   Console::WriteLine( "val[] = {{'{0}' '{1}' '{2}' '{3}'}}", val[ 0 ], val[ 1 ], val[ 2 ], val[ 3 ] );
   result = String::Join( sep, val, 1, 2 );
   Console::WriteLine( "String::Join(sep, val, 1, 2) = '{0}'", result );
}

/*
This example produces the following results:
sep = ', '
val[] = {'apple' 'orange' 'grape' 'pear'}
String::Join(sep, val, 1, 2) = 'orange, grape'
*/

String[] val = {"apple", "orange", "grape", "pear"};
String sep   = ", ";
String result;

Console.WriteLine("sep = '{0}'", sep);
Console.WriteLine("val[] = {{'{0}' '{1}' '{2}' '{3}'}}", val[0], val[1], val[2], val[3]);
result = String.Join(sep, val, 1, 2);
Console.WriteLine("String.Join(sep, val, 1, 2) = '{0}'", result);

// This example produces the following results:
// sep = ', '
// val[] = {'apple' 'orange' 'grape' 'pear'}
// String.Join(sep, val, 1, 2) = 'orange, grape'

open System

let vals = [| "apple"; "orange"; "grape"; "pear" |]
let sep   = ", "

printfn $"sep = '{sep}'"
printfn $"vals[] = {{'{vals[0]}' '{vals[1]}' '{vals[2]}' '{vals[3]}'}}"
let result = String.Join(sep, vals, 1, 2)
printfn $"String.Join(sep, vals, 1, 2) = '{result}'"

// This example produces the following results:
// sep = ', '
// vals[] = {'apple' 'orange' 'grape' 'pear'}
// String.Join(sep, vals, 1, 2) = 'orange, grape'

Class Sample
   Public Shared Sub Main()
      Dim val As [String]() =  {"apple", "orange", "grape", "pear"}
      Dim sep As [String] = ", "
      Dim result As [String]
      
      Console.WriteLine("sep = '{0}'", sep)
      Console.WriteLine("val() = {{'{0}' '{1}' '{2}' '{3}'}}", val(0), val(1), val(2), val(3))
      result = [String].Join(sep, val, 1, 2)
      Console.WriteLine("String.Join(sep, val, 1, 2) = '{0}'", result)
   End Sub
End Class 
'This example displays the following output:
'       sep = ', '
'       val() = {'apple' 'orange' 'grape' 'pear'}
'       String.Join(sep, val, 1, 2) = 'orange, grape'

Comentários

Por exemplo, se separator for ", " e os elementos de value são "maçã", "laranja", "uva" e "pera", Join(separator, value, 1, 2) retorna "laranja, uva".

Caso separator seja null, uma cadeia de caracteres vazia (String.Empty) é usada em seu lugar. Se algum elemento em value for null, uma cadeia de caracteres vazia será usada.

Confira também

Split(Char[])

Aplica-se a

Join<T>(String, IEnumerable<T>)

Concatena os membros de uma coleção, usando o separador especificado entre cada membro.

public:
generic <typename T>
 static System::String ^ Join(System::String ^ separator, System::Collections::Generic::IEnumerable<T> ^ values);

public static string Join<T> (string separator, System.Collections.Generic.IEnumerable<T> values);

public static string Join<T> (string? separator, System.Collections.Generic.IEnumerable<T> values);

[System.Runtime.InteropServices.ComVisible(false)]
public static string Join<T> (string separator, System.Collections.Generic.IEnumerable<T> values);

static member Join : string * seq<'T> -> string

[<System.Runtime.InteropServices.ComVisible(false)>]
static member Join : string * seq<'T> -> string

Public Shared Function Join(Of T) (separator As String, values As IEnumerable(Of T)) As String

Parâmetros de tipo

T

O tipo dos membros de values.

Parâmetros

separator: String

A cadeia de caracteres a ser usada como um separador. separator estará incluído na cadeia de caracteres retornada somente se values tiver mais de um elemento.

values: IEnumerable<T>

Uma coleção que contém os objetos a serem concatenados.

Retornos

String

Uma cadeia de caracteres composta pelos elementos de values delimitados pela cadeia de caracteres separator.

-ou-

Empty se values não tiver elementos.

Atributos: ComVisibleAttribute

Exceções

ArgumentNullException

values é null.

OutOfMemoryException

O comprimento da cadeia de caracteres resultante excede o comprimento máximo permitido (Int32.MaxValue).

Exemplos

O exemplo a seguir usa o algoritmo Sieve of Eratosthenes para calcular os números principais menores que ou iguais a 100. Ele atribui o resultado a um List<T> objeto do tipo inteiro, que, em seguida, passa para o Join<T>(String, IEnumerable<T>) método .

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      int maxPrime = 100;
      List<int> primes = GetPrimes(maxPrime);
      Console.WriteLine("Primes less than {0}:", maxPrime);
      Console.WriteLine("   {0}", String.Join(" ", primes));
   }

   private static List<int> GetPrimes(int maxPrime)
   {
      Array values = Array.CreateInstance(typeof(int), 
                              new int[] { maxPrime - 1}, new int[] { 2 });
      // Use Sieve of Eratosthenes to determine prime numbers.
      for (int ctr = values.GetLowerBound(0); ctr <= (int) Math.Ceiling(Math.Sqrt(values.GetUpperBound(0))); ctr++)
      {
                           
         if ((int) values.GetValue(ctr) == 1) continue;
         
         for (int multiplier = ctr; multiplier <=  maxPrime / 2; multiplier++)
            if (ctr * multiplier <= maxPrime)
               values.SetValue(1, ctr * multiplier);
      }      
      
      List<int> primes = new List<int>();
      for (int ctr = values.GetLowerBound(0); ctr <= values.GetUpperBound(0); ctr++)
         if ((int) values.GetValue(ctr) == 0) 
            primes.Add(ctr);
      return primes;
   }   
}
// The example displays the following output:
//    Primes less than 100:
//       2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

open System

let getPrimes maxPrime =
    let values = Array.CreateInstance(typeof<int>, [| maxPrime - 1 |], [| 2 |])
    // Use Sieve of Eratosthenes to determine prime numbers.
    for i = values.GetLowerBound 0 to values.GetUpperBound 0 |> float |> sqrt |> ceil |> int do
        if values.GetValue i <> 1 then
            for multiplier = i to maxPrime / 2 do
                if i * multiplier <= maxPrime then
                    values.SetValue(1, i * multiplier)

    let primes = ResizeArray()
    for i = values.GetLowerBound 0 to values.GetUpperBound 0 do
        if values.GetValue i :?> int = 0 then
            primes.Add i
    primes

let maxPrime = 100
let primes = getPrimes maxPrime
printfn $"Primes less than {maxPrime}:"
printfn $"""   {String.Join(" ", primes)}"""
// The example displays the following output:
//    Primes less than 100:
//       2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim maxPrime As Integer = 100
      Dim primes As List(Of Integer) = GetPrimes(maxPrime)
      Console.WriteLine("Primes less than {0}:", maxPrime)
      Console.WriteLine("   {0}", String.Join(" ", primes))
   End Sub
   
   Private Function GetPrimes(maxPrime As Integer) As List(Of Integer)
      Dim values As Array = Array.CreateInstance(GetType(Integer), _
                              New Integer() { maxPrime - 1}, New Integer(){ 2 }) 
        ' Use Sieve of Eratosthenes to determine prime numbers.
      For ctr As Integer = values.GetLowerBound(0) To _
                           CInt(Math.Ceiling(Math.Sqrt(values.GetUpperBound(0))))
         If CInt(values.GetValue(ctr)) = 1 Then Continue For
         
         For multiplier As Integer = ctr To maxPrime \ 2
            If ctr * multiplier <= maxPrime Then values.SetValue(1, ctr * multiplier)
         Next   
      Next      
      
      Dim primes As New System.Collections.Generic.List(Of Integer)
      For ctr As Integer = values.GetLowerBound(0) To values.GetUpperBound(0)
         If CInt(values.GetValue(ctr)) = 0 Then primes.Add(ctr)
      Next            
      Return primes
   End Function   
End Module
' The example displays the following output:
'    Primes less than 100:
'       2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

Comentários

Caso separator seja null, uma cadeia de caracteres vazia (String.Empty) é usada em seu lugar. Se qualquer membro de for null, uma cadeia de values caracteres vazia será usada.

Join<T>(String, IEnumerable<T>) é um método de conveniência que permite concatenar cada membro de uma IEnumerable<T> coleção sem primeiro convertê-los em cadeias de caracteres. A representação de cadeia de caracteres de cada objeto na IEnumerable<T> coleção é derivada chamando o método desse ToString objeto.

Esse método é particularmente útil com expressões de consulta linq (consulta Language-Integrated). Por exemplo, o código a seguir define uma classe muito simples Animal que contém o nome de um animal e a ordem à qual ele pertence. Em seguida, ele define um List<T> objeto que contém vários Animal objetos. O Enumerable.Where método de extensão é chamado para extrair os Animal objetos cuja Order propriedade é igual a "Roedor". O resultado é passado para o Join<T>(String, IEnumerable<T>) método .

using System;
using System.Collections.Generic;
using System.Linq;

public class Animal
{
   public string Kind;
   public string Order;
   
   public Animal(string kind, string order)
   {
      this.Kind = kind;
      this.Order = order;
   }
   
   public override string ToString()
   {
      return this.Kind;
   }
}

public class Example
{
   public static void Main()
   {
      List<Animal> animals = new List<Animal>();
      animals.Add(new Animal("Squirrel", "Rodent"));
      animals.Add(new Animal("Gray Wolf", "Carnivora"));
      animals.Add(new Animal("Capybara", "Rodent"));
      string output = String.Join(" ", animals.Where( animal => 
                      (animal.Order == "Rodent")));
      Console.WriteLine(output);  
   }
}
// The example displays the following output:
//      Squirrel Capybara

// This example uses F#'s Seq.filter function instead of Linq.
open System

type Animal =
  { Kind: string
    Order: string }
    override this.ToString() =
        this.Kind

let animals = ResizeArray()
animals.Add { Kind = "Squirrel"; Order = "Rodent" }
animals.Add { Kind = "Gray Wolf"; Order = "Carnivora" }
animals.Add { Kind = "Capybara"; Order = "Rodent" }
String.Join(" ", animals |> Seq.filter (fun animal -> animal.Order = "Rodent"))
|> printfn "%s"
// The example displays the following output:
//      Squirrel Capybara

Imports System.Collections.Generic

Public Class Animal
   Public Kind As String
   Public Order As String
   
   Public Sub New(kind As String, order As String)
      Me.Kind = kind
      Me.Order = order
   End Sub
   
   Public Overrides Function ToString() As String
      Return Me.Kind
   End Function
End Class

Module Example
   Public Sub Main()
      Dim animals As New List(Of Animal)
      animals.Add(New Animal("Squirrel", "Rodent"))
      animals.Add(New Animal("Gray Wolf", "Carnivora"))
      animals.Add(New Animal("Capybara", "Rodent")) 
      Dim output As String = String.Join(" ", animals.Where(Function(animal) _
                                           animal.Order = "Rodent"))
      Console.WriteLine(output)                                           
   End Sub
End Module
' The example displays the following output:
'      Squirrel Capybara

Confira também

Split(Char[])

Aplica-se a

Join<T>(Char, IEnumerable<T>)

Concatena os membros de uma coleção, usando o separador especificado entre cada membro.

public:
generic <typename T>
 static System::String ^ Join(char separator, System::Collections::Generic::IEnumerable<T> ^ values);

public static string Join<T> (char separator, System.Collections.Generic.IEnumerable<T> values);

static member Join : char * seq<'T> -> string

Public Shared Function Join(Of T) (separator As Char, values As IEnumerable(Of T)) As String

Parâmetros de tipo

T

O tipo dos membros de values.

Parâmetros

separator: Char

O caractere a ser usado como um separador. separator estará incluído na cadeia de caracteres retornada somente se values tiver mais de um elemento.

values: IEnumerable<T>

Uma coleção que contém os objetos a serem concatenados.

Retornos

String

Uma cadeia de caracteres que consiste em membros de values delimitados pelo caractere separator.

-ou-

Empty se values não tiver elementos.

Exceções

ArgumentNullException

values é null.

OutOfMemoryException

O comprimento da cadeia de caracteres resultante excede o comprimento máximo permitido (Int32.MaxValue).

Aplica-se a

String.Join Método

Definição

Sobrecargas

Join(Char, Object[])

Parâmetros

Retornos

Exceções

Aplica-se a

Join(Char, String[])

Parâmetros

Retornos

Exceções

Aplica-se a

Join(String, IEnumerable<String>)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Join(String, Object[])

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Join(String, String[])

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Join(Char, String[], Int32, Int32)

Parâmetros

Retornos

Exceções

Aplica-se a

Join(String, String[], Int32, Int32)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Join<T>(String, IEnumerable<T>)

Parâmetros de tipo

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Join<T>(Char, IEnumerable<T>)

Parâmetros de tipo

Parâmetros

Retornos

Exceções

Aplica-se a

Recursos adicionais