If you really like the ergonomics of Array.Join, you can add an [Extension Method][1] like this:

```cs
public static class MyExtensions {
	public static string Join(this IEnumerable<string> arr, string seperator) =>
		string.Join(seperator, arr);
}
```

And then use like this:

```cs
var list = new string[] {"A", "B", "C"};
var output = list.Join(",");
// "A,B,C"
```

### [Demo in .NET Fiddle][2]

[1]: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/extension-methods
[2]: https://dotnetfiddle.net/4HMObc

Ok, this is a dumb thing that I'm sure I've done dozens of times but for some reason I can't find it.

I have an array... And want to get a string with the contents of that array separated by a delimited...

Where is the .Join() method that I can't find?

(This is .Net 2.0, I don't have any LINQ stuff)

Thank you!

Array.Join in .Net?

They should perform and behave the same - the difference is in developer semantics

Here's a sample demo:

```sql
-- Setup
DECLARE @Codeset TABLE (id INT, [name] VARCHAR(50));
DECLARE @Student TABLE (id INT, [name] VARCHAR(50), age INT);

INSERT INTO @Codeset  
VALUES (1, 'HomeRoom');

INSERT INTO @Student  
VALUES (1, 'Jolly', 20), 
       (2, 'Sally', 22);
```

Let's say we want back every row from `@Student` and also to bring back the name value from `@Codeset`:

```none
| id | name  | age | name     |
|----|-------|-----|----------|
| 1  | Jolly | 20  | HomeRoom |
| 2  | Sally | 22  | HomeRoom |
```

Any of the following syntaxes will accomplish this when either table has 0, 1, or 1+ records:

```sql
-- INNER JOIN 1=1
SELECT s.id, s.[name], s.age, c.[name]
FROM @Student s
INNER JOIN @Codeset c ON 1=1

-- Multiple From tables
SELECT s.id, s.[name], s.age, c.[name]
FROM @Student s,
     @Codeset c

-- CROSS JOIN
SELECT s.id, s.[name], s.age, c.[name]
FROM @Student s
CROSS JOIN @Codeset c
```

In this situation, you should prefer [**`CROSS JOIN`**][1] to be as explicit as possible as to your intentions to build a single select statement from multiple unrelated tables


> **Note**: `CROSS JOIN` will output the same as `INNER JOIN ON 1=1`.  Both produce the Cartesian product of all rows in both rowsets, so if one table is empty, the results will be as well. 
>
> If you need to guarantee results when `@Students` has records, but `@Codeset` might be empty, you will need to use `LEFT JOIN ON 1=1`

**See Also**: [Correct way to select from two tables in SQL Server with no common field to join on][2]

[1]: https://learn.microsoft.com/en-us/u-sql/statements-and-expressions/select/from/joins/cross-join
[2]: https://stackoverflow.com/q/17582313/1366033

I am joining a large table in postgresql to a table with 1 row in it. Yes, I know I could just take the values from this single row table and put them in my query written out, but there's 210 columns.

So my question is this: should I join up the single row table to everything using a cross join or using a regular join on a tautology (1 = 1 or something). Is either of those ways bound to be slower?

Or is there a third faster way?