Interning Strings and immutability

RE: Interning Strings & immutability

Oisin — Wed, 23 Apr 2003 11:47:00 GMT

Chris, again you make it appear easy to just babble on coherently about a difficult topic -- your words poke a finger in the eye of complexity. If I tried to explain this to someone in as many words, it would be meaningless. Keep it up! - Oisin

RE: Interning Strings & immutability

Chris Brumme — Wed, 23 Apr 2003 17:18:00 GMT

The CLR Interop team agreed with me: I do find the marshaling directives bewildering! They pointed out that I should have mentioned that StringBuilder is the preferred way to call unmanaged methods that mutate strings. (Be sure to set the capacity of the StringBuilder high enough to accept the text that will be placed in it). The VBByRefStr technique is really there for VB compatibility reasons.

RE: Interning Strings & immutability

Payo — Fri, 16 May 2003 04:17:00 GMT

First of all I´d like to congratulate you for your weblog, it´s really impressive. And now the question: when you talk about mutating strings and say: "Well, you can certainly use C#’s ‘unsafe’ feature or equivalent unverifiable ILASM or Managed C++ code to write into a string’s buffer." could you give me an example of this with C# and pointers? I know how to do it with MSIL, but in C# I don´t know how to make a pointer point to the memory address pointed by an object reference (a string in this case). Maybe this is a stupid question, but I would really apreciate your answer. Thanks a lot for sharing your knowledge with us.

RE: Interning Strings & immutability

Chris Brumme — Mon, 19 May 2003 18:59:00 GMT

Payo, With strings, the trick is the m_firstChar field, which gives you addressability over the string buffer. Here's a lame example, that probably writes the first character of strIn throughout a returned string of the same size. (I haven't tested it). It shows how you can use C-style dereferencing via '*' or via array syntax. unsafe static string SlamFirst strIn) { int length = strIn.Length; String strOut = FastAllocateString(length); fixed (char * inBuff = &strIn.m_firstChar, outBuff = &strOut.m_firstChar) { char c = *inBuff; for(int i = 0; i < length; i++) { outBuff[i] = c; } return strOut; } With normal structs and classes, use explicit or sequential layout so that the C# compiler can predict what the CLR's loader will decide with respect to layout decisions. When using constructs like this, be sure to mark your code as 'unsafe' and compile it with /unsafe.

RE: Interning Strings & immutability

Payo — Tue, 20 May 2003 02:30:00 GMT

Thanks a lot for your answer. I´d just found one way to make it work: // stupid sample code fixed(char* s1p=s1) { for(int i=0;i<4;i++) { *(s1p+i)='t'; } } At first I was quite confused with all this stuff because I thought the fixed statement was something "optional" (if you were willing to have problems with the GC and object reallocation), and when I tried to compile the code above without the fixed statement the csc gave me this not too clear error: "can not implicity convert type string to char* " Using the fixed statement (so it looks it´s more or less compulsory) there´s no compiler error. There was a small problem with the code you submitted, I guess you are one of the developers of the string class, so you are used to work with private fields and methods like m_firstChar and FastAllocateString, but I´m in the "outer world", so I don´t have access to those private fields-methods :-)

Dangerous PInvokes - string modification

Yun Jin's WebLog — Sun, 22 Feb 2004 03:30:00 GMT

Dangerous PInvokes - string modification

Yun Jin's WebLog — Sun, 22 Feb 2004 05:27:00 GMT

Dangerous PInvokes - string modification

Yun Jin's WebLog — Sun, 22 Feb 2004 07:43:00 GMT

re: Interning Strings & immutability

David Goldstein — Wed, 14 Apr 2004 16:59:00 GMT

Chris,
There are times where if there were a safe place to have all your strings interned, you can write far more efficient code...
like in Object Spaces, they seem to assume that you can compare strings using == and do this many thousands of times per second as the cost of integer compares...
for my own O/R mapping projects, it's either use == for strings, find some painful way of avoiding strings altogether (source code generation) or generate dynamic assemblies (yes, this is the ideal).

re: Interning Strings & immutability

Chris Brumme — Wed, 14 Apr 2004 18:32:00 GMT

If you control the strings, you can explicitly intern them before proceeding with any comparisons (String.Intern, String.IsInterned). Rather than going through operator== (which performs String comparisons on objects that are statically typed as String), you can use Object.ReferenceEquals (which just compares the two references).

re: Interning Strings & immutability

William Stacey — Fri, 04 Jun 2004 06:53:00 GMT

Say you have a domainName hash table. And users send domainName queries to it (e.g. dns) You internal all ownerNames in all RRs. Now you get a query with ownerName "www.test.com". Should you intern that string and compare with your hash of ownerNames? That would seem fast, but would not the intern pool grow out of control as your adding strings to the pool even if ownername did not exist? Do strings ever expire out of the intern pool if no ref to them? TIA

re: Interning Strings & immutability

Chris Brumme — Fri, 04 Jun 2004 16:21:00 GMT

If you Intern a string in an AppDomain, the Intern'ed string will remain until the AppDomain is unloaded. So it's reasonable for you to Intern all the ownerNames, but it wouldn't be reasonable for you to Intern random test strings to see if you have a match.

Instead, use the String.IsInterned method on the random test string. If it isn't already interned, there's no point in trying to match it. If it is interned already, then you aren't growing the set of Interned strings and you can now proceed with an efficient comparison against your Interned ownerNames.

re: Optimising Strings in .Net

Jase's Blog — Tue, 17 Aug 2004 10:13:00 GMT

String Basics Part II

K. Scott Allen — Sat, 23 Jul 2005 18:19:13 GMT

The sample code in this post demonstrates that the run time maintains a string intern pool. The intern...

Shared Bytes, Private Bytes and Fixups

See Win App — Wed, 19 Jul 2006 09:04:45 GMT

This post is actually a re-post of a post I did a little under year ago during PDC '05 after attending...

Shared Bytes, Private Bytes and Fixups » Wagalulu - Microsoft » » Shared Bytes, Private Bytes and Fixups

Wed, 19 Jul 2006 09:09:42 GMT

PingBack from http://microsoft.wagalulu.com/2006/07/19/shared-bytes-private-bytes-and-fixups/

.NET 2.0 string interning inside out

B# .NET Blog — Wed, 27 Sep 2006 12:12:32 GMT

Introduction
Time for some cool .NET 2.0 feature that might prove useful in some scenarios: string interning....

OJ’s rants … » Blog Archive » The Day Job

OJ’s rants … » Blog Archive » The Day Job — Wed, 04 Oct 2006 10:58:41 GMT

PingBack from http://rant.blackapache.net/2006/10/04/the-day-job/

Strings Don’t Add Up : C# 411

Strings Don’t Add Up : C# 411 — Wed, 05 Mar 2008 17:34:25 GMT

PingBack from http://www.csharp411.com/strings-dont-add-up/

Exigency In Specie / A Whole Load of Empty

Exigency In Specie / A Whole Load of Empty — Mon, 24 Nov 2008 21:35:48 GMT

PingBack from http://www.peat.me.uk/2007/06/01/a-whole-load-of-empty/

String Basics in .NET | Mohammed Osman Blog US MS IT Hyderabad India

String Basics in .NET | Mohammed Osman Blog US MS IT Hyderabad India — Wed, 31 Dec 2008 01:15:44 GMT

PingBack from http://mdosman.us/?p=249

cbrumme s WebLog Interning Strings and immutability | Quick Diets

cbrumme s WebLog Interning Strings and immutability | Quick Diets — Sat, 13 Jun 2009 17:22:58 GMT

PingBack from http://quickdietsite.info/story.php?id=7394