String.Join Método

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

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

Retornos

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

- ou -

Empty se values não tiver elementos.

Exceções

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

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

Retornos

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

- ou -

Empty se value não tiver elementos.

Exceções

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

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

Retornos

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

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

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

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

Retornos

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

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

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

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

Retornos

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

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)

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

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

Retornos

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

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

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

Retornos

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

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

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

• Split(Char[])

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

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

Parâmetros

Retornos

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

-ou-

Empty se values não tiver elementos.

Exceções

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

Origem:

String.Manipulation.cs

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

Parâmetros

Retornos

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

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