String.Join Metoda

Definice

Zřetězí prvky zadaného pole nebo členů kolekce pomocí zadaného oddělovače mezi jednotlivými prvky nebo členy.

Přetížení

Join(Char, Object[])

Zřetězí řetězcové reprezentace pole objektů pomocí zadaného oddělovače mezi každým členem.

Join(Char, String[])

Zřetězí pole řetězců pomocí zadaného oddělovače mezi každým členem.

Join(String, IEnumerable<String>)

Zřetězí členy konstruované IEnumerable<T> kolekce typu String pomocí zadaného oddělovače mezi každým členem.

Join(String, Object[])

Zřetězí prvky pole objektu pomocí zadaného oddělovače mezi jednotlivými prvky.

Join(String, String[])

Zřetězí všechny prvky pole řetězců pomocí zadaného oddělovače mezi jednotlivými prvky.

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

Zřetězí pole řetězců pomocí zadaného oddělovače mezi jednotlivými členy počínaje prvkem v value startIndex umístění a zřetězením až po count prvky.

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

Zřetězí zadané prvky pole řetězců pomocí zadaného oddělovače mezi jednotlivými prvky.

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

Zřetězí členy kolekce pomocí zadaného oddělovače mezi každým členem.

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

Zřetězí členy kolekce pomocí zadaného oddělovače mezi každým členem.

Join(Char, Object[])

Zřetězí řetězcové reprezentace pole objektů pomocí zadaného oddělovače mezi každým členem.

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

Parametry

separator
Char

Znak, který má být použit jako oddělovač. separator je zahrnut ve vráceném řetězci pouze v případě, že value má více než jeden prvek.

values
Object[]

Pole objektů, jejichž řetězcové reprezentace budou zřetězeny.

Návraty

String

Řetězec, který se skládá z prvků values oddělených separator znakem.

-nebo-

Emptyvalues, pokud má nulové prvky.

Výjimky

value je null.

Délka výsledného řetězce přetéká maximální povolenou délku ( MaxValue ).

Platí pro

Join(Char, String[])

Zřetězí pole řetězců pomocí zadaného oddělovače mezi každým členem.

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

Parametry

separator
Char

Znak, který má být použit jako oddělovač. separator je zahrnut ve vráceném řetězci pouze v případě, že value má více než jeden prvek.

value
String[]

Pole řetězců, které mají být zřetězeny.

Návraty

String

Řetězec, který se skládá z prvků value oddělených separator znakem.

-nebo-

Emptyvalue, pokud má nulové prvky.

Výjimky

value je null.

Délka výsledného řetězce přetéká maximální povolenou délku ( MaxValue ).

Platí pro

Join(String, IEnumerable<String>)

Zřetězí členy konstruované IEnumerable<T> kolekce typu String pomocí zadaného oddělovače mezi každým členem.

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

Parametry

separator
String

Řetězec, který chcete použít jako oddělovač.separator je zahrnut ve vráceném řetězci pouze v případě, že values má více než jeden prvek.

values
IEnumerable<String>

Kolekce obsahující řetězce, které mají být zřetězeny.

Návraty

String

Řetězec, který se skládá z prvků values oddělené separator řetězcem.

-nebo-

Emptyvalues, pokud má nulové prvky.

Atributy

Výjimky

values je null.

Délka výsledného řetězce přetéká maximální povolenou délku ( MaxValue ).

Příklady

Následující příklad používá algoritmus Eratosthenova síta k výpočtu prvočísel, která jsou menší nebo rovná hodnotě 100. Přiřadí výsledek List<T> objektu typu String , který pak předá Join(String, IEnumerable<String>) metodě.

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

Poznámky

Pokud separator je null , String.Empty použije se místo toho prázdný řetězec (). Pokud je některý z values členů null , je místo toho použit prázdný řetězec.

Join(String, IEnumerable<String>) je pohodlná metoda, která umožňuje zřetězit každý prvek v IEnumerable(Of String) kolekci bez předchozího převedení prvků na pole řetězců. Je zvláště užitečné pro výrazy dotazů Language-Integrated Query (LINQ). Následující příklad předá List(Of String) objekt, který obsahuje velká nebo malá písmena abecedy na lambda výraz, který vybere písmena, která jsou rovna nebo větší než konkrétní písmeno (což je v příkladu "M"). IEnumerable(Of String)Kolekce vrácená Enumerable.Where metodou je předána Join(String, IEnumerable<String>) metodě pro zobrazení výsledku jako jednoho řetězce.

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

Viz také

Platí pro

Join(String, Object[])

Zřetězí prvky pole objektu pomocí zadaného oddělovače mezi jednotlivými prvky.

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

Parametry

separator
String

Řetězec, který chcete použít jako oddělovač. separator je zahrnut ve vráceném řetězci pouze v případě, že values má více než jeden prvek.

values
Object[]

Pole obsahující prvky, které mají být zřetězeny.

Návraty

String

Řetězec, který se skládá z prvků values oddělené separator řetězcem.

-nebo-

Emptyvalues, pokud má nulové prvky.

-nebo-

pouze .NET Framework: Empty pokud je první prvek prvku values null .

Atributy

Výjimky

values je null.

Délka výsledného řetězce přetéká maximální povolenou délku ( MaxValue ).

Příklady

Následující příklad používá algoritmus Eratosthenova síta k výpočtu prvočísel, která jsou menší nebo rovná hodnotě 100. Přiřadí výsledek k poli typu Integer, které pak předá Join(String, Object[]) metodě.

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

Poznámky

Pokud separator je null nebo, je-li nějaký values jiný prvek než první prvek null , je String.Empty místo toho použit prázdný řetězec (). Pokud je první prvek prvku, podívejte se do části poznámky pro values volající null .

Join(String, Object[]) je pohodlná metoda, která umožňuje zřetězit každý prvek v poli objektů bez explicitního převodu jeho prvků na řetězce. Řetězcové vyjádření každého objektu v poli je odvozeno voláním ToString metody objektu.

Poznámky pro volající

pouze .NET Framework: pokud je prvním prvkem values null , Join(String, Object[]) metoda nezřetězí prvky v, values ale místo toho vrátí Empty . K dispozici je několik alternativních řešení pro tento problém. Nejjednodušší je přiřadit hodnotu Empty k prvnímu prvku pole, jak ukazuje následující příklad.

Viz také

Platí pro

Join(String, String[])

Zřetězí všechny prvky pole řetězců pomocí zadaného oddělovače mezi jednotlivými prvky.

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

Parametry

separator
String

Řetězec, který chcete použít jako oddělovač. separator je zahrnut ve vráceném řetězci pouze v případě, že value má více než jeden prvek.

value
String[]

Pole obsahující prvky, které mají být zřetězeny.

Návraty

String

Řetězec, který se skládá z prvků v value odděleném separator řetězcem.

-nebo-

Emptyvalues, pokud má nulové prvky.

Výjimky

value je null.

Délka výsledného řetězce přetéká maximální povolenou délku ( MaxValue ).

Příklady

Následující příklad ukazuje Join metodu.

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

Poznámky

Například pokud má hodnotu separator "," a prvky pro value jsou "Apple", "oranžová", "hrozny" a "hrušky", Join(separator, value) vrátí "Apple, pomeranče, hrozny, hrušky".

Pokud separator je null , String.Empty použije se místo toho prázdný řetězec (). Pokud je nějaký element value v null , je místo toho použit prázdný řetězec.

Viz také

Platí pro

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

Zřetězí pole řetězců pomocí zadaného oddělovače mezi jednotlivými členy počínaje prvkem v value startIndex umístění a zřetězením až po count prvky.

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

Parametry

separator
Char

Zřetězí pole řetězců pomocí zadaného oddělovače mezi jednotlivými členy počínaje elementem umístěným v zadaném indexu a včetně zadaného počtu prvků.

value
String[]

Pole řetězců, které mají být zřetězeny.

startIndex
Int32

První položka, value která se má zřetězit

count
Int32

Počet prvků value , které mají být zřetězeny, počínaje prvkem na startIndex pozici.

Návraty

String

Řetězec, který se skládá z count elementů value začínajících na startIndex oddělovači separator znakem.

-nebo-

Empty Pokud count je nula.

Výjimky

value je null.

startIndex nebo count jsou záporné.

-nebo-

startIndexje větší než délka value - count .

Délka výsledného řetězce přetéká maximální povolenou délku ( MaxValue ).

Platí pro

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

Zřetězí zadané prvky pole řetězců pomocí zadaného oddělovače mezi jednotlivými prvky.

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

Parametry

separator
String

Řetězec, který chcete použít jako oddělovač. separator je zahrnut ve vráceném řetězci pouze v případě, že value má více než jeden prvek.

value
String[]

Pole obsahující prvky, které mají být zřetězeny.

startIndex
Int32

První prvek, value který má být použit.

count
Int32

Počet prvků, které value mají být použity.

Návraty

String

Řetězec, který se skládá z count elementů value začínajících na startIndex oddělovači separator znakem.

-nebo-

Empty Pokud count je nula.

Výjimky

value je null.

startIndex nebo count je menší než 0.

-nebo-

startIndex plus count je větší než počet elementů v value .

Nedostatek paměti

Příklady

Následující příklad zřetězí dva prvky z pole názvů ovoce.

// 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'
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'

Poznámky

Například pokud má hodnotu separator "," a prvky pro value jsou "Apple", "oranžová", "hrozny" a "hrušky", Join(separator, value, 1, 2) vrátí "oranžová," hrozny ".

Pokud separator je null , String.Empty použije se místo toho prázdný řetězec (). Pokud je nějaký element value v null , je místo toho použit prázdný řetězec.

Viz také

Platí pro

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

Zřetězí členy kolekce pomocí zadaného oddělovače mezi každým členem.

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

Parametry typu

T

Typ členů values .

Parametry

separator
Char

Znak, který má být použit jako oddělovač. separator je zahrnut ve vráceném řetězci pouze v případě, že values má více než jeden prvek.

values
IEnumerable<T>

Kolekce obsahující objekty, které mají být zřetězeny.

Návraty

String

Řetězec, který se skládá ze členů values oddělených separator znakem.

-nebo-

Emptyvalues, pokud nemá žádné elementy.

Výjimky

values je null.

Délka výsledného řetězce přetéká maximální povolenou délku ( MaxValue ).

Platí pro

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

Zřetězí členy kolekce pomocí zadaného oddělovače mezi každým členem.

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

Parametry typu

T

Typ členů values .

Parametry

separator
String

Řetězec, který chcete použít jako oddělovač. separator je zahrnut ve vráceném řetězci pouze v případě, že values má více než jeden prvek.

values
IEnumerable<T>

Kolekce obsahující objekty, které mají být zřetězeny.

Návraty

String

Řetězec, který se skládá z prvků values oddělené separator řetězcem.

-nebo-

Emptyvalues, pokud nemá žádné elementy.

Atributy

Výjimky

values je null.

Délka výsledného řetězce přetéká maximální povolenou délku ( MaxValue ).

Příklady

Následující příklad používá algoritmus Eratosthenova síta k výpočtu prvočísel, která jsou menší nebo rovná hodnotě 100. Přiřadí výsledek List<T> objektu typu Integer, který pak předá Join<T>(String, IEnumerable<T>) metodě.

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

Poznámky

Pokud separator je null , String.Empty použije se místo toho prázdný řetězec (). Pokud je některý z values členů null , je místo toho použit prázdný řetězec.

Join<T>(String, IEnumerable<T>) je pohodlná metoda, která umožňuje zřetězení jednotlivých členů IEnumerable<T> kolekce bez jejich první konverze na řetězce. Řetězcové vyjádření každého objektu v IEnumerable<T> kolekci je odvozeno voláním ToString metody objektu.

Tato metoda je užitečná zejména u výrazů dotazů Language-Integrated Query (LINQ). Například následující kód definuje velmi jednoduchou Animal třídu, která obsahuje název zvíře a pořadí, ke kterému patří. Pak definuje List<T> objekt, který obsahuje určitý počet Animal objektů. Enumerable.WhereMetoda rozšíření je volána pro extrakci Animal objektů, jejichž Order vlastnost se rovná "hlodavce". Výsledek je předán Join<T>(String, IEnumerable<T>) metodě.

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

Viz také

Platí pro