Строки

С точки зрения регулярного программирования строковый тип данных string относится к числу самых важных в C#. Этот тип определяет и поддерживает символьные строки. В целом ряде других языков программирования строка представляет собой массив символов. А в C# строки являются объектами. Следовательно, тип string относится к числу ссылочных.

Построение строк

Самый простой способ построить символьную строку — воспользоваться строковым литералом. Например, в следующей строке кода переменной ссылки на строку str присваивается ссылка на строковый литерал:

string str = "Пример строки";

В данном случае переменная str инициализируется последовательностью символов "Пример строки". Объект типа string можно также создать из массива типа char. Например:

char[] chararray = {'e', 'x', 'a', 'm', 'p', 'l', 'e'};
string str = new string(chararray);

Как только объект типа string будет создан, его можно использовать везде, где только требуется строка текста, заключенного в кавычки.

Постоянство строк

Как ни странно, содержимое объекта типа string не подлежит изменению. Это означает, что однажды созданную последовательность символов изменить нельзя. Но данное ограничение способствует более эффективной реализации символьных строк. Поэтому этот, на первый взгляд, очевидный недостаток на самом деле превращается в преимущество. Так, если требуется строка в качестве разновидности уже имеющейся строки, то для этой цели следует создать новую строку, содержащую все необходимые изменения. А поскольку неиспользуемые строковые объекты автоматически собираются в "мусор", то о дальнейшей судьбе ненужных строк можно даже не беспокоиться.

Следует, однако, подчеркнуть, что переменные ссылки на строки (т.е. объекты типа string) подлежат изменению, а следовательно, они могут ссылаться на другой объект. Но содержимое самого объекта типа string не меняется после его создания.

Рассмотрим пример:

static void addNewString()
{
	string s = "This is my stroke";
	s = "This is new stroke";
}

Скомпилируем приложение и загрузим результирующую сборку в утилиту ildasm.exe. На рисунке показан CIL-код, который будет сгенерирован для метода void addNewString():

Обратите внимание на наличие многочисленных вызовов кода операции ldstr (загрузка строки). Этот код операции ldstr в CIL предусматривает выполнение загрузки нового объекта string в управляемую кучу. В результате предыдущий объект, в котором содержалось значение "This is my stroke", будет в конечном итоге удален сборщиком мусора.

Работа со строками

В классе System.String предоставляется набор методов для определения длины символьных данных, поиска подстроки в текущей строке, преобразования символов из верхнего регистра в нижний и наоборот, и т.д. Далее мы рассмотрим этот класс более подробно.

Поле, индексатор и свойство класса String

В классе String определено единственное поле:

public static readonly string Empty;

Поле Empty обозначает пустую строку, т.е. такую строку, которая не содержит символы. Этим оно отличается от пустой ссылки типа String, которая просто делается на несуществующий объект.

Помимо этого, в классе String определен единственный индексатор, доступный только для чтения:

public char this[int index] { get; }

Этот индексатор позволяет получить символ по указанному индексу. Индексация строк, как и массивов, начинается с нуля. Объекты типа String отличаются постоянством и не изменяются, поэтому вполне логично, что в классе String поддерживается индексатор, доступный только для чтения.

И наконец, в классе String определено единственное свойство, доступное только для чтения:

public int Length { get; }

Свойство Length возвращает количество символов в строке. В примере ниже показано использование индексатора и свойства Length:

using System;

class Example
{
    static void Main()
    {
        string str = "Простая строка";

        // Получить длину строки и 6й символ в строке используя индексатор
        Console.WriteLine("Длина строки - {0}, 6й символ - '{1}'",
            str.Length, str[5]);
    }
}

Операторы класса String

В классе String перегружаются два следующих оператора: == и !=. Оператор == служит для проверки двух символьных строк на равенство. Когда оператор == применяется к ссылкам на объекты, он обычно проверяет, делаются ли обе ссылки на один и тот же объект. А когда оператор == применяется к ссылкам на объекты типа String, то на предмет равенства сравнивается содержимое самих строк. Это же относится и к оператору !=. Когда он применяется к ссылкам на объекты типа String, то на предмет неравенства сравнивается содержимое самих строк. В то же время другие операторы отношения, в том числе < и >=, сравнивают ссылки на объекты типа String таким же образом, как и на объекты других типов. А для того чтобы проверить, является ли одна строка больше другой, следует вызвать метод Compare(), определенный в классе String.

Как станет ясно дальше, во многих видах сравнения символьных строк используются сведения о культурной среде. Но это не относится к операторам == и !=. Ведь они просто сравнивают порядковые значения символов в строках. (Иными словами, они сравнивают двоичные значения символов, не видоизмененные нормами культурной среды, т.е. региональными стандартами.) Следовательно, эти операторы выполняют сравнение строк без учета регистра и настроек культурной среды.

Методы класса String

В следующей таблице перечислены некоторые наиболее интересные методы этого класса, сгруппированные по назначению:

Методы работы со строками

Пример следующей программы использует несколько из вышеуказанных методов:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // Сравним первые две строки
            string s1 = "это строка";
            string s2 = "это текст, а это строка";

            if (String.CompareOrdinal(s1, s2) != 0)
                Console.WriteLine("Строки s1 и s2 не равны");

            if (String.Compare(s1, 0, s2, 13, 10, true) == 0)
                Console.WriteLine("При этом в них есть одинаковый текст");

            // Конкатенация строк
            Console.WriteLine(String.Concat("\n" + "Один, два ","три, четыре"));

            // Поиск в строке
             // Первое вхождение подстроки
             if (s2.IndexOf("это") != -1)
                Console.WriteLine("Слово \"это\" найдено в строке, оно "+ 
                 "находится на: {0} позиции", s2.IndexOf("это"));

             // Последнее вхождение подстроки
             if (s2.LastIndexOf("это") != -1)
                 Console.WriteLine("Последнее вхождение слова \"это\" находится "
                     + "на {0} позиции", s2.LastIndexOf("это"));

             // Поиск из массива символов
             char[] myCh = {'Ы','х','т'};
             if (s2.IndexOfAny(myCh) != -1)
                 Console.WriteLine("Один из символов из массива ch "+
                     "найден в текущей строке на позиции {0}", s2.IndexOfAny(myCh));
             
             // Определяем начинается ли строка с заданной подстроки
             if (s2.StartsWith("это текст") == true)
                 Console.WriteLine("Подстрока найдена!");

             // Определяем содержится ли в строке подстрока
             // на примере определения ОС пользователя
             string myOS = Environment.OSVersion.ToString();
             if (myOS.Contains("NT 5.1"))
                 Console.WriteLine("Ваша операционная система Windows XP");
            
            Console.ReadLine();
        }

    }
}

Немного о сравнении строк в C#

Вероятно, из всех операций обработки символьных строк чаще всего выполняется сравнение одной строки с другой. Прежде чем рассматривать какие-либо методы сравнения строк, следует подчеркнуть следующее: сравнение строк может быть выполнено в среде .NET Framework двумя основными способами:

• Во-первых, сравнение может отражать обычаи и нормы отдельной культурной среды, которые зачастую представляют собой настройки культурной среды, вступающие в силу при выполнении программы. Это стандартное поведение некоторых, хотя и не всех методов сравнения.

• И во-вторых, сравнение может быть выполнено независимо от настроек культурной среды только по порядковым значениям символов, составляющих строку. Вообще говоря, при сравнении строк без учета культурной среды используется лексикографический порядок (и лингвистические особенности), чтобы определить, является ли одна строка больше, меньше или равной другой строке. При порядковом сравнении строки просто упорядочиваются на основании невидоизмененного значения каждого символа.

В силу отличий способов сравнения строк с учетом культурной среды и порядкового сравнения, а также последствий каждого такого сравнения настоятельно рекомендуется руководствоваться лучшими методиками, предлагаемыми в настоящее время корпорацией Microsoft. Ведь выбор неверного способа сравнения строк может привести к неправильной работе программы, когда она эксплуатируется в среде, отличающей от той, в которой она разработана.

Выбор способа сравнения символьных строк представляет собой весьма ответственное решение. Как правило и без всяких исключений, следует выбирать сравнение строк с учетом культурной среды, если это делается для целей отображения результата пользователю (например, для вывода на экран ряда строк, отсортированных в лексикографическом порядке). Но если строки содержат фиксированную информацию, не предназначенную для видоизменения с учетом отличий в культурных средах, например, имя файла, ключевое слово, адрес веб-сайта или значение, связанное с обеспечением безопасности, то следует выбрать порядковое сравнение строк. Разумеется, особенности конкретного разрабатываемого приложения будут диктовать выбор подходящего способа сравнения символьных строк.

В классе String предоставляются самые разные методы сравнения строк, которые перечислены в таблице выше. Наиболее универсальным среди них является метод Compare(). Он позволяет сравнивать две строки полностью или частично, с учетом или без учета регистра, способа сравнения, определяемого параметром типа StringComparison, а также сведений о культурной среде, предоставляемых с помощью параметра типа CultureInfo.

Те перегружаемые варианты метода Compare(), которые не содержат параметр типа StringComparison, выполняют сравнение символьных строк с учетом регистра и культурной среды. А в тех перегружаемых его вариантах, которые не содержат параметр типа CultureInfo, сведения о культурной среде определяются текущей средой выполнения.

Тип StringComparison представляет собой перечисление, в котором определяются значения, приведенные в таблице ниже. Используя эти значения, можно организовать сравнение строк, удовлетворяющее потребностям конкретного приложения. Следовательно, добавление параметра типа StringComparison расширяет возможности метода Compare() и других методов сравнения, например, Equals(). Это дает также возможность однозначно указывать способ предполагаемого сравнения строк.

В силу имеющих отличий между сравнением строк с учетом культурной среды и порядковым сравнением очень важно быть предельно точным в этом отношении.

Значения, определяемые в перечислении StringComparison

В любом случае метод Compare() возвращает отрицательное значение, если первая сравниваемая строка оказывается меньше второй; положительное значение, если первая сравниваемая строка больше второй; и наконец, нуль, если обе сравниваемые строки равны. Несмотря на то что метод Compare() возвращает нуль, если сравниваемые строки равны, для определения равенства символьных строк, как правило, лучше пользоваться методом Equals() или же оператором ==.

Дело в том, что метод Compare() определяет равенство сравниваемых строк на основании порядка их сортировки. Так, если выполняется сравнение строк с учетом культурной среды, то обе строки могут оказаться одинаковыми по порядку их сортировки, но не равными по существу. По умолчанию равенство строк определяется в методе Equals(), исходя из порядковых значений символов и без учета культурной среды. Следовательно, по умолчанию обе строки сравниваются в этом методе на абсолютное, посимвольное равенство подобно тому, как это делается в операторе ==.

Несмотря на большую универсальность метода Compare(), для простого порядкового сравнения символьных строк проще пользоваться методом CompareOrdinal(). И наконец, следует иметь в виду, что метод CompareTo() выполняет сравнение строк только с учетом культурной среды.

В приведенной ниже программе демонстрируется применение методов Compare(), Equals(), CompareOrdinal(), а также операторов == и != для сравнения символьных строк. Обратите внимание на то, что два первых примера сравнения наглядно демонстрируют отличия между сравнением строк с учетом культурной среды и порядковым сравнением в англоязычной среде:

using System;

class Example
{
    static void Main()
    {
        string str1 = "alpha";
        string str2 = "Alpha";
        string str3 = "Beta";
        string str4 = "alpha";
        string str5 = "alpha, beta";
        int result;
        
        // Сначала продемонстрировать отличия между сравнением строк
        // с учетом культурной среды и порядковым сравнением
        result = String.Compare(str1, str2, StringComparison.CurrentCulture);
        Console.Write("Сравнение строк с учетом культурной среды: ");
        
        if (result < 0)
            Console.WriteLine(str1 + " меньше " + str2);
        else if(result > 0)
            Console.WriteLine(str1 + " больше " + str2);
        else
            Console.WriteLine(str1 + " равно " + str2);
        
        result = String.Compare(str1, str2, StringComparison.Ordinal);
        Console.Write("Порядковое сравнение строк: ");
        if (result < 0)
            Console.WriteLine(str1 + " меньше " + str2);
        else if(result > 0)
            Console.WriteLine(str1 + " больше " + str2);
        else 
            Console.WriteLine(str1 + " равно " + str4);

        // Использовать метод CompareOrdinal()
        result = String.CompareOrdinal(str1, str2);
        Console.Write("Сравнение строк методом CompareOrdinal():\n");
        if (result < 0)
            Console.WriteLine(str1 + " меньше " + str2);
        else if(result > 0)
            Console.WriteLine(str1 + " больше " + str2);
        else
            Console.WriteLine(str1 + " равно " + str4);
        Console.WriteLine();

        // Определить равенство строк с помощью оператора ==
        // Это порядковое сравнение символьных строк
        if (str1 == str4) 
            Console.WriteLine(str1 + " == " + str4);

        // Определить неравенство строк с помощью оператора !=
        if(str1 != str3) 
            Console.WriteLine(str1 + " != " + str3);
        
        if(str1 != str2) 
            Console.WriteLine(str1 + " != " + str2);
        Console.WriteLine();
        
        // Выполнить порядковое сравнение строк без учета регистра,
        // используя метод Equals()
        if(String.Equals(str1, str2, StringComparison.OrdinalIgnoreCase))
            Console.WriteLine("Сравнение строк методом Equals() с " + 
                "параметром OrdinalIgnoreCase:\n" + 
                str1 + " равно " + str2);
        Console.WriteLine ();

        // Сравнить части строк
        if(String.Compare(str2, 0, str5, 0, 3,
            StringComparison.CurrentCulture) > 0) {
            Console.WriteLine("Сравнение строк с учетом текущей культурной среды:" + 
                "\n3 первых символа строки " + str2 + 
                " больше, чем 3 первых символа строки " + str5);
        }
    }
}

Выполнение этой программы приводит к следующему результату: