String.Join Método

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.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(String, String[])	Concatena todos os elementos de uma matriz de cadeia de caracteres, usando o separador especificado entre cada elemento.
Join(String, ReadOnlySpan<String>)	Concatena um intervalo de cadeias de caracteres, usando o separador especificado entre cada membro.
Join(String, String[], Int32, Int32)	Concatena os elementos especificados 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é `count` elementos.
Join(String, ReadOnlySpan<Object>)	Concatena as representações de cadeia de caracteres de um intervalo de objetos, usando o separador especificado entre cada membro.
Join(Char, ReadOnlySpan<Object>)	Concatena as representações de cadeia de caracteres de um intervalo de objetos, 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(Char, Object[])	Concatena as representações de cadeia de caracteres de uma matriz de objetos, 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(Char, ReadOnlySpan<String>)	Concatena um intervalo de cadeias de caracteres, usando o separador especificado entre cada membro.
Join(Char, String[])	Concatena uma matriz de cadeias de caracteres, 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<T>(String, IEnumerable<T>)	Concatena os membros de uma coleção, usando o separador especificado entre cada membro.

Join(String, String[])

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

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 separador. separator será 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 serem concatenares.

Retornos

String

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

-ou-

Empty se value não tiver elementos.

Exceções

ArgumentNullException

value é null.

OutOfMemoryException

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

Exemplos

O exemplo a seguir demonstra o método Join.

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".

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

Confira também

Concat(Object)

Aplica-se a

Join(String, ReadOnlySpan<String>)

Concatena um intervalo de cadeias de caracteres, usando o separador especificado entre cada membro.

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

public static string Join (string? separator, scoped ReadOnlySpan<string?> value);

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

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

Parâmetros

separator: String

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

value: ReadOnlySpan<String>

Um intervalo que contém os elementos a serem concatenares.

Retornos

String

Uma cadeia de caracteres que consiste nos elementos de value delimitados pela cadeia de caracteres separator. -ou- Empty se value não tiver elementos.

Aplica-se a

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

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

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 separador. separator será 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 serem concatenares.

startIndex: Int32

O primeiro elemento em value a ser usado.

count: Int32

O número de elementos de value a serem usados.

Retornos

String

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

-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 forem "maçã", "laranja", "uva" e "pera", Join(separator, value, 1, 2) retornará "laranja, uva".

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

Confira também

Split(Char[])

Aplica-se a

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

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

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é count elementos.

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 para concatenar.

count: Int32

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

Retornos

String

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

-ou-

Empty se count for zero.

Exceções

ArgumentNullException

value é null.

ArgumentOutOfRangeException

startIndex ou count são negativos.

-ou-

startIndex é maior que o comprimento de value - count.

OutOfMemoryException

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

Aplica-se a

Join(String, ReadOnlySpan<Object>)

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

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

public static string Join (string? separator, scoped ReadOnlySpan<object?> values);

static member Join : string * ReadOnlySpan<obj> -> string

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

Parâmetros

separator: String

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

values: ReadOnlySpan<Object>

Um intervalo de objetos cujas representações de cadeia de caracteres serão concatenadas.

Retornos

String

Uma cadeia de caracteres que consiste nos elementos de values delimitados pela cadeia de caracteres separator. -ou- Empty se values não tiver elementos.

Aplica-se a

Join(Char, ReadOnlySpan<Object>)

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

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

public static string Join (char separator, scoped ReadOnlySpan<object?> values);

static member Join : char * ReadOnlySpan<obj> -> string

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

Parâmetros

separator: Char

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

values: ReadOnlySpan<Object>

Um intervalo de objetos cujas representações de cadeia de caracteres serão concatenadas.

Retornos

String

Uma cadeia de caracteres que consiste nos elementos de values delimitados pelo caractere separator. -ou- Empty se values não tiver elementos.

Aplica-se a

Join(String, IEnumerable<String>)

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

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 separador. separator será 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 concatenas.

Retornos

String

Uma cadeia de caracteres que consiste nos 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 primos que são menores ou iguais a 100. Ele atribui o resultado a um objeto List<T> do tipo String, que ele passa para o método Join(String, IEnumerable<String>).

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

Se separator for null, uma cadeia de caracteres vazia (String.Empty) será usada. Se qualquer membro do values for null, uma cadeia de caracteres vazia será usada.

Join(String, IEnumerable<String>) é um método de conveniência que permite concatenar cada elemento em uma coleção IEnumerable(Of String) sem primeiro converter os elementos em uma matriz de cadeia de caracteres. É particularmente útil com expressões de consulta LINQ (consulta Language-Integrated). O exemplo a seguir passa um objeto List(Of String) 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 coleção IEnumerable(Of String) retornada pelo método Enumerable.Where é passada para o método Join(String, IEnumerable<String>) 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(Char, Object[])

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

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 separador. separator será incluído na cadeia de caracteres retornada somente se values 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 que consiste nos elementos 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

Join(String, Object[])

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

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 separador. separator será 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 serem concatenares.

Retornos

String

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

-ou-

Empty se values não tiver elementos.

-ou-

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

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 primos que são menores ou iguais a 100. Ele atribui o resultado a uma matriz de inteiros, que passa para o método Join(String, Object[]).

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 de values diferente do primeiro elemento for null, uma cadeia de caracteres vazia (String.Empty) será usada. Consulte a seção Anotações para Chamadores se o primeiro elemento do 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 ToString desse objeto.

Notas aos Chamadores

Somente .NET Framework: se o primeiro elemento de values for null, o método Join(String, Object[]) não concatenará os elementos em values mas retornará Empty. 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(Char, ReadOnlySpan<String>)

Concatena um intervalo de cadeias de caracteres, usando o separador especificado entre cada membro.

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

public static string Join (char separator, scoped ReadOnlySpan<string?> value);

static member Join : char * ReadOnlySpan<string> -> string

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

Parâmetros

separator: Char

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

value: ReadOnlySpan<String>

Um intervalo que contém os elementos a serem concatenares.

Retornos

String

Uma cadeia de caracteres que consiste nos elementos de value delimitados pela cadeia de caracteres separator. -ou- Empty se value não tiver elementos.

Aplica-se a

Join(Char, String[])

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

Concatena uma matriz 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 separador. separator será 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 que consiste nos 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 excede o comprimento máximo permitido (Int32.MaxValue).

Aplica-se a

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

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

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 do values.

Parâmetros

separator: Char

O caractere a ser usado como separador. separator será 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 concatenar.

Retornos

String

Uma cadeia de caracteres que consiste nos 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

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

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

Origem:: String.Manipulation.cs

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 do values.

Parâmetros

separator: String

A cadeia de caracteres a ser usada como separador. separator será 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 concatenar.

Retornos

String

Uma cadeia de caracteres que consiste nos 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 primos que são menores ou iguais a 100. Ele atribui o resultado a um objeto List<T> de tipo inteiro, que ele passa para o método Join<T>(String, IEnumerable<T>).

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

Se separator for null, uma cadeia de caracteres vazia (String.Empty) será usada. Se qualquer membro do values for null, uma cadeia de caracteres vazia será usada.

Join<T>(String, IEnumerable<T>) é um método de conveniência que permite concatenar cada membro de uma coleção IEnumerable<T> sem primeiro convertê-los em cadeias de caracteres. A representação de cadeia de caracteres de cada objeto na coleção IEnumerable<T> é derivada chamando o método ToString desse 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 de Animal muito simples que contém o nome de um animal e a ordem à qual ele pertence. Em seguida, define um objeto List<T> que contém uma série de objetos Animal. O método de extensão Enumerable.Where é chamado para extrair os objetos Animal cuja propriedade Order é igual a "Roedor". O resultado é passado para o método Join<T>(String, IEnumerable<T>).

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

Compartilhar via

String.Join Método

Definição

Sobrecargas

Join(String, String[])

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Join(String, ReadOnlySpan<String>)

Parâmetros

Retornos

Aplica-se a

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

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, ReadOnlySpan<Object>)

Parâmetros

Retornos

Aplica-se a

Join(Char, ReadOnlySpan<Object>)

Parâmetros

Retornos

Aplica-se a

Join(String, IEnumerable<String>)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Join(Char, Object[])

Parâmetros

Retornos

Exceções

Aplica-se a

Join(String, Object[])

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Join(Char, ReadOnlySpan<String>)

Parâmetros

Retornos

Aplica-se a

Join(Char, String[])

Parâmetros

Retornos

Exceções

Aplica-se a

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

Parâmetros de tipo

Parâmetros

Retornos

Exceções

Aplica-se a

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

Parâmetros de tipo

Parâmetros

Retornos

Exceções

Exemplos