Aspectos de Strings em .NET

Representação de strings na memória

1. O comprimento da string é limitado por um determinado número. No PWSZ, o comprimento da string é limitado pela disponibilidade de memória livre.
2. A string BSTR sempre aponta para o primeiro caractere no buffer. O PWSZ pode apontar para qualquer caractere no buffer.
3. No BSTR, semelhante ao PWSZ, o caractere nulo está sempre localizado no final. No BSTR, o caractere nulo é um caractere válido e pode ser encontrado em qualquer lugar da string.
4. Como o terminador nulo está localizado no final, o BSTR é compatível com PWSZ, mas não vice-versa.

Quanta memória um objeto string usa?

Aspectos da string

1. Strings são tipos de referência.
2. Strings são imutáveis. Uma vez criada, uma string não pode ser modificada (por meios justos). Cada chamada do método desta classe retorna uma nova string, enquanto a string anterior se torna uma presa para o coletor de lixo.
3. Strings redefinem o método Object.Equals. Como resultado, o método compara valores de caracteres em strings, não valores de link.

• Strings são imutáveis ​​para um propósito. A imutabilidade da string tem vários benefícios:
• O tipo de string é thread-safe, pois nem um único thread pode modificar o conteúdo de uma string.
• O uso de strings imutáveis ​​leva à diminuição da carga de memória, pois não há necessidade de armazenar 2 instâncias da mesma string. Como resultado, menos memória é gasta e a comparação é executada mais rapidamente, pois apenas as referências são comparadas. Em .NET, esse mecanismo é chamado de internamento de strings (string pool). Falaremos sobre isso um pouco mais tarde.
• Ao passar um parâmetro imutável para um método, podemos parar de nos preocupar que ele será modificado (se não foi passado como ref ou out, é claro).

public final class String
	{
	    private final char value[];
	    private final int offset;
 	private final int count;
 	private int hash; 
  	.....
	}

1. Uma referência a uma matriz de caracteres;
2. Um índice do primeiro caractere da string na matriz de caracteres (deslocamento desde o início)
3. O número de caracteres na string;
4. O código de hash calculado após a primeira chamada de HashCode() método.

Implementação do método String.substring() em Java:

public String substring(int beginIndex, int endIndex) 
{
 if (beginIndex < 0) throw new StringIndexOutOfBoundsException(beginIndex); if (endIndex > count)
   throw new StringIndexOutOfBoundsException(endIndex);
 if (beginIndex > endIndex)
   throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
 return ((beginIndex == 0) && (endIndex == count)) ? this : new String(offset + beginIndex, endIndex - beginIndex, value);
}

public String(int offset, int count, char value[]) 
{
 this.value = value;
 this.offset = offset;
 this.count = count;
}

if (s1 == s2)

if (s1.Equals(s2))

Internação de strings

var s = "Strings are immutuble";
int length = s.Length;
for (int i = 0; i < length / 2; i++)
{
   var c = s[i];
   s[i] = s[length - i - 1];
   s[length - i - 1] = c;
}

var s = "Strings are immutable";
int length = s.Length;
  unsafe
   {
    fixed (char* c = s)
     {
      for (int i = 0; i < length / 2; i++)
       {
         var temp = c[i];
         c[i] = c[length - i - 1];
         c[length - i - 1] = temp;
       }
      }
   }

var s1 = "habrahabr";
var s2 = "habrahabr";
var s3 = "habra" + "habr";

Console.WriteLine(object.ReferenceEquals(s1, s2));//true
Console.WriteLine(object.ReferenceEquals(s1, s3));//true

var s = "Strings are immutable";
int length = s.Length;
unsafe
 {
  fixed (char* c = s)
   {
    for (int i = 0; i < length / 2; i++)
     {
      var temp = c[i];
      c[i] = c[length - i - 1];
      c[length - i - 1] = temp;
     }
   }
 }
Console.WriteLine("Strings are immutable");

E se esquecermos do inseguro?

internal unsafe void SetChar(int index, char value)
 {
   if ((uint)index >= (uint)this.Length)
     throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
            
   fixed (char* chPtr = &this.m_firstChar)
          chPtr[index] = value;
 }

internal unsafe void InternalSetCharNoBoundsCheck (int index, char value)
 {
   fixed (char* chPtr = &this.m_firstChar)
          chPtr[index] = value;
 }

var s = "Strings are immutable";
int length = s.Length;
var method = typeof(string).GetMethod("InternalSetCharNoBoundsCheck", BindingFlags.Instance | BindingFlags.NonPublic);
for (int i = 0; i < length / 2; i++)
  {
      var temp = s[i];
      method.Invoke(s, new object[] { i, s[length - i - 1] });
      method.Invoke(s, new object[] { length - i - 1, temp });
  }
            
 Console.WriteLine("Strings are immutable");

string str1 = String.Empty;
StringBuilder sb = new StringBuilder().Append(String.Empty);
string str2 = String.Intern(sb.ToString());	
		
if (object.ReferenceEquals(str1, str2))  
   Console.WriteLine("Equal");
else
   Console.WriteLine("Not Equal");

Aspectos de desempenho