String.Join Metod

Definition

Namnområde:
System
Sammansättningar:
mscorlib.dll, System.Runtime.dll
Sammansättningar:
netstandard.dll, System.Runtime.dll
Sammansättning:
System.Runtime.dll
Sammansättning:
mscorlib.dll
Sammansättning:
netstandard.dll

Sammanfogar elementen i en angiven matris eller medlemmarna i en samling med hjälp av den angivna avgränsaren mellan varje element eller medlem.

Överlagringar

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

Sammanfogar de angivna elementen i en strängmatris med hjälp av den angivna avgränsaren mellan varje element.
Join(Char, String[], Int32, Int32)

Sammanfogar en matris med strängar med hjälp av den angivna avgränsaren mellan varje medlem, börjar med elementet i value som finns på startIndex positionen och sammanfogar upp till count element.
Join(String, String[])

Sammanfogar alla element i en strängmatris med den angivna avgränsaren mellan varje element.
Join(String, ReadOnlySpan<String>)

Sammanfogar ett intervall med strängar med hjälp av den angivna avgränsaren mellan varje medlem.
Join(String, ReadOnlySpan<Object>)

Sammanfogar strängrepresentationerna av ett intervall med objekt med hjälp av den angivna avgränsaren mellan varje medlem.
Join(Char, ReadOnlySpan<String>)

Sammanfogar ett intervall med strängar med hjälp av den angivna avgränsaren mellan varje medlem.
Join(String, IEnumerable<String>)

Sammanfogar medlemmarna i en konstruerad IEnumerable<T> samling av typen String, med hjälp av den angivna avgränsaren mellan varje medlem.
Join(Char, String[])

Sammanfogar en matris med strängar med den angivna avgränsaren mellan varje medlem.
Join(String, Object[])

Sammanfogar elementen i en objektmatris med den angivna avgränsaren mellan varje element.
Join(Char, ReadOnlySpan<Object>)

Sammanfogar strängrepresentationerna av ett intervall med objekt med hjälp av den angivna avgränsaren mellan varje medlem.
Join(Char, Object[])

Sammanfogar strängrepresentationerna för en matris med objekt med hjälp av den angivna avgränsaren mellan varje medlem.
Join<T>(Char, IEnumerable<T>)

Sammanfogar medlemmarna i en samling med hjälp av den angivna avgränsaren mellan varje medlem.
Join<T>(String, IEnumerable<T>)

Sammanfogar medlemmarna i en samling med hjälp av den angivna avgränsaren mellan varje medlem.

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

Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs

Sammanfogar de angivna elementen i en strängmatris med hjälp av den angivna avgränsaren mellan varje element.

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

Parametrar

separator
String

Strängen som ska användas som avgränsare. separator ingår endast i den returnerade strängen om value det finns fler än ett element.

value
String[]

En matris som innehåller elementen som ska sammanfogas.

startIndex
Int32

Det första elementet som value ska användas.

count
Int32

Antalet element value som ska användas.

Returer

String

En sträng som består av count element som value börjar vid startIndex avgränsade av separator tecknet.

-eller-

Empty om count är noll.

Undantag

ArgumentNullException

value är null.

ArgumentOutOfRangeException

startIndex eller count är mindre än 0.

-eller-

startIndex plus count är större än antalet element i value.

OutOfMemoryException

Slut på minne.

Exempel

I följande exempel sammanfogas två element från en matris med namn på frukt.

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'

Kommentarer

Om till exempel separator är ", " och elementen value i är "äpple", "orange", "druva" och "päron" Join(separator, value, 1, 2) returnerar "apelsin, druva".

Om separator är nullanvänds en tom sträng (String.Empty) i stället. Om något element i är valueanvänds en tom sträng i null stället.

Se även

Gäller för

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

Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs

Sammanfogar en matris med strängar med hjälp av den angivna avgränsaren mellan varje medlem, börjar med elementet i value som finns på startIndex positionen och sammanfogar upp till count element.

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

Parametrar

separator
Char

Sammanfogar en matris med strängar med hjälp av den angivna avgränsaren mellan varje medlem, med början med elementet som finns vid det angivna indexet och inkluderar ett angivet antal element.

value
String[]

En matris med strängar som ska sammanfogas.

startIndex
Int32

Det första objektet som value sammanfogas.

count
Int32

Antalet element från value till sammanfogning, med början med elementet i startIndex positionen.

Returer

String

En sträng som består av count element som value börjar vid startIndex avgränsade av separator tecknet.

-eller-

Empty om count är noll.

Undantag

ArgumentNullException

value är null.

ArgumentOutOfRangeException

startIndex eller count är negativa.

-eller-

startIndex är större än längden på value - count.

OutOfMemoryException

Längden på den resulterande strängen flödar över den maximala tillåtna längden (Int32.MaxValue).

Gäller för

Join(String, String[])

Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs

Sammanfogar alla element i en strängmatris med den angivna avgränsaren mellan varje element.

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

Parametrar

separator
String

Strängen som ska användas som avgränsare. separator ingår endast i den returnerade strängen om value det finns fler än ett element.

value
String[]

En matris som innehåller elementen som ska sammanfogas.

Returer

String

En sträng som består av elementen i value avgränsade av strängen separator .

-eller-

Empty om value har noll element.

Undantag

ArgumentNullException

value är null.

OutOfMemoryException

Längden på den resulterande strängen flödar över den maximala tillåtna längden (Int32.MaxValue).

Exempel

I följande exempel visas Join metoden.

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

Kommentarer

Om till exempel separator är ", " och elementen value i är "äpple", "orange", "druva" och "päron", Join(separator, value) returnerar "äpple, apelsin, druva, päron".

Om separator är nullanvänds en tom sträng (String.Empty) i stället. Om något element i är valueanvänds en tom sträng i null stället.

Se även

Gäller för

Join(String, ReadOnlySpan<String>)

Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs

Sammanfogar ett intervall med strängar med hjälp av den angivna avgränsaren mellan varje medlem.

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

Parametrar

separator
String

Strängen som ska användas som avgränsare. separator ingår endast i den returnerade strängen om value det finns fler än ett element.

value
ReadOnlySpan<String>

Ett spann som innehåller de element som ska sammanfogas.

Returer

String

En sträng som består av elementen value i avgränsade av strängen separator . -or- Empty if value har noll element.

Gäller för

Join(String, ReadOnlySpan<Object>)

Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs

Sammanfogar strängrepresentationerna av ett intervall med objekt med hjälp av den angivna avgränsaren mellan varje medlem.

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

Parametrar

separator
String

Strängen som ska användas som avgränsare. separator ingår endast i den returnerade strängen om values det finns fler än ett element.

values
ReadOnlySpan<Object>

Ett intervall med objekt vars strängrepresentationer sammanfogas.

Returer

String

En sträng som består av elementen values i avgränsade av strängen separator . -or- Empty if values har noll element.

Gäller för

Join(Char, ReadOnlySpan<String>)

Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs

Sammanfogar ett intervall med strängar med hjälp av den angivna avgränsaren mellan varje medlem.

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

Parametrar

separator
Char

Tecknet som ska användas som avgränsare. separator ingår endast i den returnerade strängen om value det finns fler än ett element.

value
ReadOnlySpan<String>

Ett spann som innehåller de element som ska sammanfogas.

Returer

String

En sträng som består av elementen value i avgränsade av strängen separator . -or- Empty if value har noll element.

Gäller för

Join(String, IEnumerable<String>)

Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs

Sammanfogar medlemmarna i en konstruerad IEnumerable<T> samling av typen String, med hjälp av den angivna avgränsaren mellan varje medlem.

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

Parametrar

separator
String

Strängen som ska användas som avgränsare. separator ingår endast i den returnerade strängen om values det finns fler än ett element.

values
IEnumerable<String>

En samling som innehåller strängarna som ska sammanfogas.

Returer

String

En sträng som består av elementen values i avgränsade av strängen separator .

-eller-

Empty om values har noll element.

Attribut
ComVisibleAttribute

Undantag

ArgumentNullException

values är null.

OutOfMemoryException

Längden på den resulterande strängen flödar över den maximala tillåtna längden (Int32.MaxValue).

Exempel

I följande exempel används algoritmen Sieve för Eratosthenes för att beräkna de primära talen som är mindre än eller lika med 100. Det tilldelar resultatet till ett List<T> objekt av typen String, som sedan skickas Join(String, IEnumerable<String>) till metoden.

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

Kommentarer

Om separator är nullanvänds en tom sträng (String.Empty) i stället. Om någon medlem i values är nullanvänds en tom sträng i stället.

Join(String, IEnumerable<String>) är en bekvämlighetsmetod som gör att du kan sammanfoga varje element i en IEnumerable(Of String) samling utan att först konvertera elementen till en strängmatris. Det är särskilt användbart med linq-frågeuttryck (Language-Integrated Query). I följande exempel skickas ett List(Of String) objekt som innehåller antingen versaler eller gemener i alfabetet till ett lambda-uttryck som väljer bokstäver som är lika med eller större än en viss bokstav (som i exemplet är "M"). Samlingen IEnumerable(Of String) som returneras av Enumerable.Where metoden skickas till Join(String, IEnumerable<String>) metoden för att visa resultatet som en enda sträng.

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

Se även

Gäller för

Join(Char, String[])

Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs

Sammanfogar en matris med strängar med den angivna avgränsaren mellan varje medlem.

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

Parametrar

separator
Char

Tecknet som ska användas som avgränsare. separator ingår endast i den returnerade strängen om value det finns fler än ett element.

value
String[]

En matris med strängar som ska sammanfogas.

Returer

String

En sträng som består av elementen value i avgränsade av separator tecknet.

-eller-

Empty om value har noll element.

Undantag

ArgumentNullException

value är null.

OutOfMemoryException

Längden på den resulterande strängen flödar över den maximala tillåtna längden (Int32.MaxValue).

Gäller för

Join(String, Object[])

Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs

Sammanfogar elementen i en objektmatris med den angivna avgränsaren mellan varje element.

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

Parametrar

separator
String

Strängen som ska användas som avgränsare. separator ingår endast i den returnerade strängen om values det finns fler än ett element.

values
Object[]

En matris som innehåller elementen som ska sammanfogas.

Returer

String

En sträng som består av elementen values i avgränsade av strängen separator .

-eller-

Empty om values har noll element.

-eller-

endast .NET Framework: Empty om det första elementet i values är null.

Attribut
ComVisibleAttribute

Undantag

ArgumentNullException

values är null.

OutOfMemoryException

Längden på den resulterande strängen flödar över den maximala tillåtna längden (Int32.MaxValue).

Exempel

I följande exempel används algoritmen Sieve för Eratosthenes för att beräkna de primära talen som är mindre än eller lika med 100. Det tilldelar resultatet till en heltalsmatris, som sedan skickas Join(String, Object[]) till metoden.

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

Kommentarer

Om separator är null eller om något annat element values än det första elementet är nullanvänds en tom sträng (String.Empty) i stället. Se avsnittet Anteckningar för uppringare om det första elementet values i är null.

Join(String, Object[]) är en bekvämlighetsmetod som gör att du kan sammanfoga varje element i en objektmatris utan att uttryckligen konvertera dess element till strängar. Strängrepresentationen av varje objekt i matrisen härleds genom att objektets metod anropas ToString .

Anteckningar till anropare

endast .NET Framework: Om det första elementet i values är null sammanfogar metoden Join(String, Object[]) inte elementen i values utan returnerar i stället Empty. Det finns ett antal lösningar på det här problemet. Det enklaste är att tilldela värdet Empty till det första elementet i matrisen, vilket visas i följande exempel.

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

Se även

Gäller för

Join(Char, ReadOnlySpan<Object>)

Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs

Sammanfogar strängrepresentationerna av ett intervall med objekt med hjälp av den angivna avgränsaren mellan varje medlem.

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

Parametrar

separator
Char

Tecknet som ska användas som avgränsare. separator ingår endast i den returnerade strängen om värdet har fler än ett element.

values
ReadOnlySpan<Object>

Ett intervall med objekt vars strängrepresentationer sammanfogas.

Returer

String

En sträng som består av elementen values i avgränsade av separator tecknet. -or- Empty if values har noll element.

Gäller för

Join(Char, Object[])

Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs

Sammanfogar strängrepresentationerna för en matris med objekt med hjälp av den angivna avgränsaren mellan varje medlem.

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

Parametrar

separator
Char

Tecknet som ska användas som avgränsare. separator ingår endast i den returnerade strängen om values det finns fler än ett element.

values
Object[]

En matris med objekt vars strängrepresentationer sammanfogas.

Returer

String

En sträng som består av elementen values i avgränsade av separator tecknet.

-eller-

Empty om values har noll element.

Undantag

ArgumentNullException

values är null.

OutOfMemoryException

Längden på den resulterande strängen flödar över den maximala tillåtna längden (Int32.MaxValue).

Gäller för

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

Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs

Sammanfogar medlemmarna i en samling med hjälp av den angivna avgränsaren mellan varje medlem.

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

Typparametrar

T

Typen av medlemmar valuesi .

Parametrar

separator
Char

Tecknet som ska användas som avgränsare. separator ingår endast i den returnerade strängen om values det finns fler än ett element.

values
IEnumerable<T>

En samling som innehåller de objekt som ska sammanfogas.

Returer

String

En sträng som består av medlemmarna values i avgränsade av separator tecknet.

-eller-

Empty om values inte har några element.

Undantag

ArgumentNullException

values är null.

OutOfMemoryException

Längden på den resulterande strängen flödar över den maximala tillåtna längden (Int32.MaxValue).

Gäller för

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

Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs
Källa:
String.Manipulation.cs

Sammanfogar medlemmarna i en samling med hjälp av den angivna avgränsaren mellan varje medlem.

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

Typparametrar

T

Typen av medlemmar valuesi .

Parametrar

separator
String

Strängen som ska användas som avgränsare. separator ingår endast i den returnerade strängen om values det finns fler än ett element.

values
IEnumerable<T>

En samling som innehåller de objekt som ska sammanfogas.

Returer

String

En sträng som består av elementen values i avgränsade av strängen separator .

-eller-

Empty om values inte har några element.

Attribut
ComVisibleAttribute

Undantag

ArgumentNullException

values är null.

OutOfMemoryException

Längden på den resulterande strängen flödar över den maximala tillåtna längden (Int32.MaxValue).

Exempel

I följande exempel används algoritmen Sieve för Eratosthenes för att beräkna de primära talen som är mindre än eller lika med 100. Det tilldelar resultatet till ett List<T> objekt av typen heltal, som sedan skickas Join<T>(String, IEnumerable<T>) till metoden.

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

Kommentarer

Om separator är nullanvänds en tom sträng (String.Empty) i stället. Om någon medlem i values är nullanvänds en tom sträng i stället.

Join<T>(String, IEnumerable<T>) är en bekvämlighetsmetod som gör att du kan sammanfoga varje medlem i en IEnumerable<T> samling utan att först konvertera dem till strängar. Strängrepresentationen IEnumerable<T> av varje objekt i samlingen härleds genom att anropa objektets ToString metod.

Den här metoden är särskilt användbar med Language-Integrated frågeuttryck (LINQ). Följande kod definierar till exempel en mycket enkel Animal klass som innehåller namnet på ett djur och den ordning som det tillhör. Sedan definieras ett List<T> objekt som innehåller ett antal Animal objekt. Tilläggsmetoden Enumerable.Where anropas för att extrahera de Animal objekt vars Order egenskap är lika med "Gnagare". Resultatet skickas till Join<T>(String, IEnumerable<T>) metoden.

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

Se även

Gäller för