CODEWITHSUNDEEP
c#stringcoding-style
Matthew
Matthew

Reputation: 29264

In C#, what's the best way to spread a single-line string literal across multiple source lines?

Suppose that you have a lengthy string (> 80 characters) that you want to spread across multiple source lines, but don't want to include any newline characters.

One option is to concatenate substrings:

string longString = "Lorem ipsum dolor sit amet, consectetur adipisicing" +
    " elit, sed do eiusmod tempor incididunt ut labore et dolore magna" +
    " aliqua. Ut enim ad minim veniam";

Is there a better way, or is this the best option?

Edit: By "best", I mean easiest for the coder to read, write, and edit. For example, if you did want newlines, it's very easy to look at:

string longString =
@"Lorem ipsum dolor sit amet, consectetur adipisicing
elit, sed do eiusmod tempor incididunt ut labore et dolore magna
aliqua. Ut enim ad minim veniam";

I am wondering if there is something just as clean when you don't want newlines.

Upvotes: 66

Views: 58536

Answers (7)

Alexei - check Codidact
Alexei - check Codidact

Reputation: 23108

Following Tj Kellie answer, in C# 6.0 you can easily have one instruction to perform concatenation and embedding of various information through string interpolation and also not having newlines in spite of defining the string on multiple lines.

A complex example involving all these can look like the following:

public int? BestTime { get; set; }
public int? WorstTime { get; set; }
public int? AvgTime { get; set; }
public int TimeoutReachedCount { get; set; }
public int AllRunCount { get; set; }

public string Str => $@"
   Ran {AllRunCount} times; 
   Reached timeout {TimeoutReachedCount} times; 
   Best time = {(BestTime.HasValue ? BestTime.ToString() : "N/A")}; 
   Worst time = {(WorstTime.HasValue ? WorstTime.ToString() : "N/A")}; 
   Average time = {(AvgTime.HasValue ? AvgTime.ToString() :"N/A")};"
       .Replace(Environment.NewLine, "");

Of course, extra care must be used to append blanks at the end of the lines to avoid words merging.

Upvotes: 5

Tj Kellie
Tj Kellie

Reputation: 6476

If you want to keep the code as minimal as you can and be able to read it easily I would still go with a @ literal string. Plus its faster if you source is long and..

string verbatimLit = @" 
   __   __  
  /  `-'  \ 
 /_| N   |_\  Sometimes
   |  I  |    format in code
   |   N |    matters
   |_____|  
";

Then remove the newlines from the string in 1 line,

verbatimLit.Replace(Environment.NewLine, " ");

Upvotes: 46

Johannes Rudolph
Johannes Rudolph

Reputation: 35761

When finding yourself in question on how to do multiline strings, you might be better of using a Resources file.

Upvotes: 0

John Saunders
John Saunders

Reputation: 161831

For SQL queries or other long strings that have their own syntax, I'll sometimes do something like this:

        private const string QUERY = @"
SELECT *
FROM Table1 AS T1
INNER JOIN Table2 AS T2 ON T1.ID = T2.T1ID
WHERE T1.VALUE = @P1
GROUP BY T2.OTHERVALUE
";

This leaves the formatting of the string intact.

Upvotes: 9

Eilon
Eilon

Reputation: 25704

You could use multiple consts and then combine them into one big string:

const string part1 = "part 1";
const string part2 = "part 2";
const string part3 = "part 3";
string bigString = part1 + part2 + part3;

The compiler will "fold" these constants into one big string anyway, so there is no runtime cost at all to this technique as compared to your original code sample.

There are a number of advantages to this approach:

  1. The substrings can be easily reused in other parts of the application.
  2. The substrings can be defined in multiple files or types, if desired.

Upvotes: -4

LBushkin
LBushkin

Reputation: 131796

Your original idea is probably the easiest way to have an embedded literal string in your code. The C# compiler merges literals concatenated with + - so it's essentially equivalent to a single really long string.

Another option, of course, is to externalize the string into a configuration file or a settings file. This would allow it to be both more easily readable and easier to change or localize. I personally avoid placing long lines of text directly into the code of an application unless they are very static and don't need localization - internal exception message text, and the like.

Upvotes: 14

bobbymcr
bobbymcr

Reputation: 24177

I would use a variation of your method:

string longString =
    "Lorem ipsum dolor sit amet, consectetur adipisicing " + 
    "elit, sed do eiusmod tempor incididunt ut labore et dolore magna " + 
    "aliqua. Ut enim ad minim veniam.";

Here I start the string on the line after the equals sign so that they all line up, and I also make sure the space occurs at the end of the line (again, for alignment purposes).

Upvotes: 79

Related Questions