我知道字符串是不可变的，对字符串的任何更改只会在内存中创建一个新字符串(并将旧字符串标记为空闲)。但是，我想知道我下面的逻辑是否合理，因为您实际上可以以循环方式修改字符串的内容。

const string baseString = "The quick brown fox jumps over the lazy dog!";

//initialize a new string
string candidateString = new string('\0', baseString.Length);

//Pin the string
GCHandle gcHandle = GCHandle.Alloc(candidateString, GCHandleType.Pinned);

//Copy the contents of the base string to the candidate string
unsafe
{
    char* cCandidateString = (char*) gcHandle.AddrOfPinnedObject();
    for (int i = 0; i < baseString.Length; i++)
    {
        cCandidateString[i] = baseString[i];
    }
}

这种方法是否确实改变了内容 candidateString(没有在内存中创建新的 candidateString)，或者运行时是否看穿了我的技巧并将其视为普通字符串？

最佳答案

由于几个因素，您的示例运行良好:

• candidateString 位于托管堆中，因此修改是安全的。将其与驻留的 baseString 进行比较。如果您尝试修改 interned 字符串，可能会发生意想不到的事情。不能保证字符串在某些时候不会存在于写保护内存中，尽管它今天似乎可以工作。这与在 C 中将常量字符串分配给 char* 变量然后修改它非常相似。在 C 中，这是未定义的行为。

• 您在 candidateString 中预分配了足够的空间 - 所以您不会溢出缓冲区。

• 字符数据不存储在 String 类的偏移量 0 处。它存储在等于 RuntimeHelpers.OffsetToStringData 的偏移处。

  public static int OffsetToStringData
  {
      // This offset is baked in by string indexer intrinsic, so there is no harm
      // in getting it baked in here as well.
      [System.Runtime.Versioning.NonVersionable] 
      get {
          // Number of bytes from the address pointed to by a reference to
          // a String to the first 16-bit character in the String.  Skip 
          // over the MethodTable pointer, & String 
          // length.  Of course, the String reference points to the memory 
          // after the sync block, so don't count that.  
          // This property allows C#'s fixed statement to work on Strings.
          // On 64 bit platforms, this should be 12 (8+4) and on 32 bit 8 (4+4).
  #if WIN32
          return 8;
  #else
          return 12;
  #endif // WIN32
      }
  }
  

  除了...

• GCHandle.AddrOfPinnedObject 是两种类型的特例:字符串 和数组类型。它不是返回对象本身的地址，而是谎言并返回数据的偏移量。查看source code在 CoreCLR 中。

  // Get the address of a pinned object referenced by the supplied pinned
  // handle.  This routine assumes the handle is pinned and does not check.
  FCIMPL1(LPVOID, MarshalNative::GCHandleInternalAddrOfPinnedObject, OBJECTHANDLE handle)
  {
      FCALL_CONTRACT;
  
      LPVOID p;
      OBJECTREF objRef = ObjectFromHandle(handle);
  
      if (objRef == NULL)
      {
          p = NULL;
      }
      else
      {
          // Get the interior pointer for the supported pinned types.
          if (objRef->GetMethodTable() == g_pStringClass)
              p = ((*(StringObject **)&objRef))->GetBuffer();
          else if (objRef->GetMethodTable()->IsArray())
              p = (*((ArrayBase**)&objRef))->GetDataPtr();
          else
              p = objRef->GetData();
      }
  
      return p;
  }
  FCIMPLEND
  

总而言之，运行时允许您使用它的数据并且不会提示。毕竟你使用的是 unsafe 代码。我见过比这更糟糕的运行时困惑情况，包括在堆栈上创建引用类型；-)

如果您的最终字符串比分配的字符串短，请记住在所有字符后添加一个额外的 \0 (在偏移 Length 处) .这不会溢出，每个字符串末尾都有一个隐式空字符以简化互操作场景。

现在看看StringBuilder是如何创建字符串的，这里是StringBuilder.ToString :

[System.Security.SecuritySafeCritical]  // auto-generated
public override String ToString() {
    Contract.Ensures(Contract.Result<String>() != null);

    VerifyClassInvariant();

    if (Length == 0)
        return String.Empty;

    string ret = string.FastAllocateString(Length);
    StringBuilder chunk = this;
    unsafe {
        fixed (char* destinationPtr = ret)
        {
            do
            {
                if (chunk.m_ChunkLength > 0)
                {
                    // Copy these into local variables so that they are stable even in the presence of race conditions
                    char[] sourceArray = chunk.m_ChunkChars;
                    int chunkOffset = chunk.m_ChunkOffset;
                    int chunkLength = chunk.m_ChunkLength;

                    // Check that we will not overrun our boundaries. 
                    if ((uint)(chunkLength + chunkOffset) <= ret.Length && (uint)chunkLength <= (uint)sourceArray.Length)
                    {
                        fixed (char* sourcePtr = sourceArray)
                            string.wstrcpy(destinationPtr + chunkOffset, sourcePtr, chunkLength);
                    }
                    else
                    {
                        throw new ArgumentOutOfRangeException("chunkLength", Environment.GetResourceString("ArgumentOutOfRange_Index"));
                    }
                }
                chunk = chunk.m_ChunkPrevious;
            } while (chunk != null);
        }
    }
    return ret;
}

是的，它使用了不安全的代码，是的，您可以使用 fixed 来优化您的代码，因为这种固定类型比分配 GC 句柄轻量级得多:

const string baseString = "The quick brown fox jumps over the lazy dog!";

//initialize a new string
string candidateString = new string('\0', baseString.Length);

//Copy the contents of the base string to the candidate string
unsafe
{
    fixed (char* cCandidateString = candidateString)
    {
        for (int i = 0; i < baseString.Length; i++)
            cCandidateString[i] = baseString[i];
    }
}

当您使用fixed 时，GC 只有在收集过程中偶然发现一个对象时才会发现它需要固定。如果没有进行收集，则 GC 甚至不会参与。当你使用 GCHandle 时，每次都会在 GC 中注册一个句柄。

关于c# - 您可以通过不安全的方法更改(不可变)字符串的内容吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32464944/