|
I see. Thank you, Pete!
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
|
|
|
|
|
I'm still using String.Format method when the string is in a resource file.
For example, imagine you have this string resource:
MyStringResource = "A problem occured in {0}."
You then cannot use the new C# 6 string interpolation, and have to resort to the good old:
string location = "an undefined place";
string message = string.Format(Resources.MyStringResource, location);
Other than that, I try to use the string interpolation where I can.
Regards.
I never finish anyth
|
|
|
|
|
Also a good point, thank you!
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
|
|
|
|
|
Sascha Lefèvre wrote: interpolation built into C# 6,
I have no plans to use either. String.Format will continue to be my weapon of choice for a good long while.
The ability to compile against older versions will often outweigh the "shiny and new".
Don't use any new feature unless and until it provides a real benefit.
Consider, also, what if you write code that must compile under new and old versions? Will you write it both ways with conditional compilation? Make a branch in your version control and have to maintain two versions? Isn't it simpler to write it only the "old" way and reduce maintenance?
On the other hand, I have an Extension Method:
public static string
Format
(
this string Format
,
System.Collections.IList Parameter
)
(By the by, Extension Methods are about the newest C# feature I use, even though I feel they were implemented wrong.)
|
|
|
|
|
PIEBALDconsult wrote: The ability to compile against older versions
You can use string interpolation with older .NET versions, you just have to use the C# 6 compiler. Or am I missing your point?
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
|
|
|
|
|
|
Alright then  Richard mentioned the ASP.NET issue where you can't freely choose your compiler. Do you have another scenario where this is the case?
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
|
|
|
|
|
It's a choice. I use the oldest compiler that does what I need.
|
|
|
|
|
Fair enough
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
|
|
|
|
|
PIEBALDconsult wrote: I use the oldest compiler that does what I need.
So you're still using the A-0 System[^] then? 
"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer
|
|
|
|
|
String interpolation won't work if you're targeting anything before .NET 4.6, unless you add specific classes[^] to your project.
ASP.NET sites - particularly "Web Site" projects - are also an issue. Unless you install a local copy of the compilers in your project via a NuGet package[^], the site will be compiled using the old compilers, and no C# 6 features will work. This seems to be the case even on a system with .NET 4.6 installed, which is rather annoying.
"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer
|
|
|
|
|
Richard Deeming wrote: ASP.NET sites - particularly "Web Site" projects - are also an issue.
Another good point, thank you!
Richard Deeming wrote: String interpolation won't work if you're targeting anything before .NET 4.6, unless you add specific classes[^] to your project.
It does work in general - just the context-dependent conversion to an IFormattable does not without those helper classes.
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
|
|
|
|
|
I have personally adapted, over years, to using the bracketed place-holder syntax in strings, and it's no longer something I have to really "think about" using; and, using ReSharper, if you type: string result = "result: " + somevariable;, ReSharper will show a little flag you can click that will automatically convert that to a String.Format invocation.
The new syntax looks more "elegant," I think, but from a what-you-have-to-type point of view it looks like it would "cost" as much as the current syntax.
However, I will always be interested to see what your creative mind has come up with. And, I hope you will publish whatever you are doing with formatting.
«Tell me and I forget. Teach me and I remember. Involve me and I learn.» Benjamin Franklin
|
|
|
|
|
BillWoodruff wrote: The new syntax looks more "elegant,"
Yes, that's the point for me. When dealing with very large format strings with many placeholders the numeric syntax makes it very non-intuitive what the result will be. I found some custom solutions that accomplished about the same as the new C# 6 syntax but they were really slow, comparatively, because they used RegEx'.
BillWoodruff wrote: I hope you will publish whatever you are doing with formatting.
I will!
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
|
|
|
|
|
As I am working alone on all my projects, I've instantly moved to C#6 as it came out. I actually tried the CTP already (only in a minor project, though).
After all I can say that I used ReSharper to convert my whole project to interpolation. It's way easier to use and cleaner to read. There are situations, though, when you have to use string.Format() or custom implementations. But this is rather rare.
I love all C#6 features and use them quite a lot. Especially because ReSharper notifies me about everything that can be made easier with the new language features.
|
|
|
|
|
GravityPhazer wrote: There are situations, though, when you have to use string.Format() or custom implementations.
Can you name one (or more) from the top of your head that hasn't been mentioned yet?
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
|
|
|
|
|
Ah sorry, withdraw that. I thought I had a problem using conditional with strings:
Write($"Test is {(isTest ? "enabled" : "disabled")}");
But I obviously just mixed up something with the brackets.
That, though, is something that's clearly some kind of disadvantage: Using something like this makes it kinda difficult to read ore more like difficult to find the error if you place any bracket wrong (or have any other kind of syntax issue). At least if you use a lot and/or complex expressions.
But I still prefer interpolation 
I personally had to get used to it first, though. I think it's nicer to use than string.Format() and although I built a string extension method which let's me quick format a string, I think this is better to use. I think it's definetly an advantage that you actually see which variable or value you have at that spot. With format you just see the index there and have to check which value is actually being set (especially when you got >4 elements with an object array).
But like I said, in the beginning I forgot most of the time to first write the indicator sign $, and thus had to go back - which is indeed more time consuming then. But that's just temporary.
|
|
|
|
|
Yep, I like it too, in general. Things like your example or if you have a deeply nested value then make it less readable again. That's why I still like my custom solution (not the first of its kind) better in those cases:
string text = "Test is {enabled}. Also {foo}.".XFormat(new
{
enabled = isTest ? "enabled" : "disabled",
foo = some.Really.Deep.Nested.Value[index]
});
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
|
|
|
|
|
Well, I haven't ever thought about using anonymous classes for that.
I've written something that makes it easier (since I not only forget $ but also string.Format() at the beginning) by formatting at the end, like with your example. But using the same approach as the default format:
var myString = "Test value 1 is {0} and value two is {1}".FormatWith(value1, value2);
The cool thing is that thanks to ReSharper you can tag that method as formatting method, and thus it highlights the placeholder braces if you use that method on a string. Pretty neat!
But using anonymous types for that is a nice idea, as well. I should implement that, too 
PS: I should mention I implemented that method far before anonymous types were supported.
|
|
|
|
|
GravityPhazer wrote: But using anonymous types for that is a nice idea, as well. I should implement that, too
Unless you want to do it for kicks, you might want to wait for my article on that
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
|
|
|
|
|
I don't have much time at the moment so you're article will likely be out before I can even start on that. Exams, deadlines and stuff are keeping me away from programming fun :-/
But writing my article was fun enough for this week and a good break from learning 
|
|
|
|
|
GravityPhazer wrote: I love all C#6 features and use them quite a lot.
I love writing code that I think others in the future will have a hope of figuring out without jumping through loops to do so.
And I appreciate those rare occasions when I must maintain someone else's code were they were more focused on implementing the needed business functionality in a straightforward manner and where they actually took the time to think about real error conditions and how to maintain the code when it runs in production.
Of course none of that has anything to do with the language that it is written in. Applies equally to C#, Java, C++, Flavors of SQL, perl and even OS script languages.
|
|
|
|
|
Sascha Lefèvre wrote:
Do you have a project where fast string formatting is critical?
Can't ever recall where that ever was an issue ever.
Worked on a project where reading and parsing text fast was a concern. But turn out via profiling and production metrics that language specific IO was sufficient with some minor tweaks.
Sascha Lefèvre wrote: Now that we have string interpolation
For me I can't see that as anything but syntactic sugar that provides no real benefit. To be fair the only thing I work on is back end servers so consequently the vast majority of strings I usually work with are logging strings.
|
|
|
|
|
jschell wrote: For me I can't see that as anything but syntactic sugar
Sure that, but
jschell wrote: that provides no real benefit
to me improved readability is a great benefit. Especially when you have a format string with a couple more than just 2-3 placeholders where some of them even repeat the index-notation becomes really cryptic.
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
|
|
|
|
|
Sascha Lefèvre wrote: to me improved readability is a great benefit.
Only study I have ever seen that was even close to objectively measuring "readability" was one related to font choices in marketing material.
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
