Текст книги "C# 4.0: полное руководство"
Автор книги: Герберт Шилдт
Жанр:
Программирование
сообщить о нарушении
Текущая страница: 14 (всего у книги 83 страниц)
Как пояснялось в главе 3, в версии C# 3.0 появилась возможность объявлять неявно типизированные переменные с помощью ключевого слова var. Это переменные, тип которых определяется компилятором, исходя из типа инициализирующего выражения. Следовательно, все неявно типизированные переменные должны быть непременно инициализированы. Используя тот же самый механизм, можно создать и неявно типизированный массив. Как правило, неявно типизированные массивы предназначены для применения в определенного рода вызовах, включающих в себя элементы языка LINQ, о котором речь пойдет в главе 19. А в большинстве остальных случаев используется «обычное» объявление массивов. Неявно типизированные массивы рассматриваются здесь лишь ради полноты представления о возможностях языка С#.
Неявно типизированный массив объявляется с помощью ключевого слова var, но без последующих квадратных скобок [ ]. Кроме того, неявно типизированный массив должен быть непременно инициализирован, поскольку по типу инициализаторов определяется тип элементов данного массива. Все инициализаторы должны быть одного и того же согласованного типа. Ниже приведен пример объявления неявно типизированного массива.
var vals = new[] { 1, 2, 3, 4, 5 };
В данном примере создается массив типа int, состоящий из пяти элементов. Ссылка на этот массив присваивается переменной vals. Следовательно, тип этой переменной соответствует типу int массива, состоящего из пяти элементов. Обратите внимание на то, что в левой части приведенного выше выражения отсутствуют квадратные скобки [ ]. А в правой части этого выражения, где происходит инициализация массива, квадратные скобки присутствуют. В данном контексте они обязательны.
Рассмотрим еще один пример, в котором создается двумерный массив типа double.
var vals = new[,] { {1.1, 2.2}, {3.3, 4.4}, { 5.5, 6.6} };
В данном случае получается массив vals размерами 2x3.
Объявлять можно также неявно типизированные ступенчатые массивы. В качестве примера рассмотрим следующую программу.
// Продемонстрировать неявно типизированный ступенчатый массив.
using System;
class Jagged {
static void Main() {
var jagged = new[] {
new[] { 1, 2, 3, 4 },
new[] { 9, 8, 7 },
new[] { 11, 12, 13, 14, 15 }
};
for(int j = 0; j < jagged.Length; j++) {
for(int i = 0; i < jagged[j].Length; i++)
Console.Write(jagged[j] [i] + " ") ;
Console.WriteLine();
}
}
}
Выполнение этой программы дает следующий результат.
1 2 3 4
9 8 7
11 12 13 14 15
Обратите особое внимание на объявление массива jagged.
var jagged = new[] {
new[] { 1, 2, 3, 4 },
new[] { 9, 8, 7 },
new[] { 11, 12, 13, 14, 15 }
};
Как видите, оператор new[] используется в этом объявлении двояким образом. Во-первых, этот оператор создает массив массивов. И во-вторых, он создает каждый массив в отдельности, исходя из количества инициализаторов и их типа. Как и следовало ожидать, все инициализаторы отдельных массивов должны быть одного и того же типа. Таким образом, к объявлению любого неявно типизированного ступенчатого массива применяется тот же самый общий подход, что и к объявлению обычных ступенчатых массивов.
Как упоминалось выше, неявно типизированные массивы чаще всего применяются в LINQ-ориентированных запросах. А в остальных случаях следует использовать явно типизированные массивы.
Как упоминалось в главе 5, в языке C# определен оператор цикла foreach, но его рассмотрение было отложено до более подходящего момента. Теперь этот момент настал.
Оператор foreach служит для циклического обращения к элементам коллекции, представляющей собой группу объектов. В C# определено несколько видов коллекций, каждая из которых является массивом. Ниже приведена общая форма оператора цикла foreach.
foreach (тип имя_переменной_цикла in коллекция) оператор;
Здесь тип имя_переменной_цикла обозначает тип и имя переменной управления циклом, которая получает значение следующего элемента коллекции на каждом шаге выполнения цикла foreach. А коллекция обозначает циклически опрашиваемую коллекцию, которая здесь и далее представляет собой массив. Следовательно, тип переменной цикла должен соответствовать типу элемента массива. Кроме того, тип может обозначаться ключевым словом var. В этом случае компилятор определяет тип переменной цикла, исходя из типа элемента массива. Это может оказаться полезным для работы с определенного рода запросами, как будет показано далее в данной книге. Но, как правило, тип указывается явным образом.
Оператор цикла foreach действует следующим образом. Когда цикл начинается, первый элемент массива выбирается и присваивается переменной цикла. На каждом последующем шаге итерации выбирается следующий элемент массива, который сохраняется в переменной цикла. Цикл завершается, когда все элементы массива окажутся выбранными. Следовательно, оператор foreach циклически опрашивает массив по отдельным его элементам от начала и до конца.
Следует, однако, иметь в виду, что переменная цикла в операторе foreach служит только для чтения. Это означает, что, присваивая этой переменной новое значение, нельзя изменить содержимое массива.
Ниже приведен простой пример применения оператора цикла foreach. В этом примере сначала создается целочисленный массив и задается ряд его первоначальных значений, а затем эти значения выводятся, а по ходу дела вычисляется их сумма.
// Использовать оператор цикла foreach.
using System;
class ForeachDemo {
static void Main() {
int sum = 0;
int[] nums = new int [10];
// Задать первоначальные значения элементов массива nums.
for(int i = 0; i < 10; i++) nums[i] = i;
// Использовать цикл foreach для вывода значений
// элементов массива и подсчета их суммы,
foreach(int х in nums) {
Console.WriteLine("Значение элемента равно: " + х); sum += х;
}
Console.WriteLine("Сумма равна: " + sum);
}
}
Выполнение приведенного выше кода дает следующий результат.
Значение элемента равно: 0
Значение элемента равно: 1
Значение элемента равно: 2
Значение элемента равно: 3
Значение элемента равно: 4
Значение элемента равно: 5
Значение элемента равно: 6
Значение элемента равно: 7
Значение элемента равно: 8
Значение элемента равно: 9
Сумма равна: 45
Как видите, оператор foreach циклически опрашивает массив по порядку индексирования от самого первого до самого последнего его элемента.
Несмотря на то что цикл foreach повторяется до тех пор, пока не будут опрошены все элементы массива, его можно завершить преждевременно, воспользовавшись оператором break. Ниже приведен пример программы, в которой суммируются только пять первых элементов массива nums.
// Использовать оператор break для преждевременного завершения цикла foreach.
using System;
class ForeachDemo {
static void Main() {
int sum = 0;
int[] nums = new int[10];
// Задать первоначальные значения элементов массива nums.
for(int i = 0; i < 10; i++) nums[i] = i;
// Использовать цикл foreach для вывода значений
// элементов массива и подсчета их суммы.
foreach(int x in nums) {
Console.WriteLine("Значение элемента равно: " + x);
sum += x;
if(x == 4) break; // прервать цикл, как только индекс массива достигнет 4
}
Console.WriteLine("Сумма первых 5 элементов: " + sum);
}
}
Вот какой результат дает выполнение этой программы.
Значение элемента равно: 0
Значение элемента равно: 1
Значение элемента равно: 2
Значение элемента равно: 3
Значение элемента равно: 4
Сумма первых 5 элементов: 10
Совершенно очевидно, что цикл foreach завершается после выбора и вывода значения пятого элемента массива.
Оператор цикла foreach можно также использовать для циклического обращения к элементам многомерного массива. В этом случае элементы многомерного массива возвращаются по порядку следования строк от первой до последней, как демонстрирует приведенный ниже пример программы.
// Использовать оператор цикла foreach для обращения к двумерному массиву.
using System;
class ForeachDemo2 {
static void Main() {
int sum = 0;
int[,] nums = new int[3,5];
// Задать первоначальные значения элементов массива nums.
for (int i = 0; i < 3; i++)
for (int j=0; j < 5; j++)
nums[i,j] = (i + 1) * (j + 1);
// Использовать цикл foreach для вывода значений
// элементов массива и подсчета их суммы,
foreach(int х in nums) {
Console.WriteLine("Значение элемента равно: " + х);
sum += х;
}
Console.WriteLine("Сумма равна: " + sum);
}
}
Выполнение этой программы дает следующий результат.
Значение элемента равно: 1
Значение элемента равно: 2
Значение элемента равно: 3
Значение элемента равно: 4
Значение элемента равно: 5
Значение элемента равно: 2
Значение элемента равно: 4
Значение элемента равно: 6
Значение элемента равно: 8
Значение элемента равно: 10
Значение элемента равно: 3
Значение элемента равно: 6
Значение элемента равно: 9
Значение элемента равно: 12
Значение элемента равно: 15
Сумма равна: 90
Оператор foreach допускает циклическое обращение к массиву только в определенном порядке: от начала и до конца массива, поэтому его применение кажется, на первый взгляд, ограниченным. Но на самом деле это не так. В большом числе алгоритмов, самым распространенным из которых является алгоритм поиска, требуется именно такой механизм. В качестве примера ниже приведена программа, в которой цикл foreach используется для поиска в массиве определенного значения. Как только это значение будет найдено, цикл прервется.
// Поиск в массиве с помощью оператора цикла foreach.
using System;
class Search {
static void Main() {
int[] nums = new int [10];
int val;
bool found = false;
// Задать первоначальные значения элементов массива nums.
for (int i = 0; i < 10; i++)
nums[i] = i;
val = 5;
// Использовать цикл foreach для поиска заданного
// значения в массиве nums.
foreach(int x in nums) {
if(x == val) {
found = true;
break;
}
}
if(found)
Console.WriteLine(«Значение найдено!»);
}
}
При выполнении этой программы получается следующий результат.
Значение найдено!
Оператор цикла foreach отлично подходит для такого применения, поскольку при поиске в массиве приходится анализировать каждый его элемент. К другим примерам применения оператора цикла foreach относится вычисление среднего, поиск минимального или максимального значения среди ряда заданных значений, обнаружение дубликатов и т.д. Как будет показано далее в этой книге, оператор цикла foreach оказывается особенно полезным для работы с разными типами коллекций.
С точки зрения регулярного программирования строковый тип данных string относится к числу самых важных в С#. Этот тип определяет и поддерживает символьные строки. В целом ряде других языков программирования строка представляет собой массив символов. А в C# строки являются объектами. Следовательно, тип string относится к числу ссылочных. И хотя string является встроенным в C# типом данных, его рассмотрение пришлось отложить до тех пор, пока не были представлены классы и объекты.
На самом деле класс типа string уже не раз применялся в примерах программ, начиная с главы 2, но это обстоятельство выясняется только теперь, когда очередь дошла до строк. При создании строкового литерала в действительности формируется строковый объект. Например, в следующей строке кода:
Console.WriteLine(«В C# строки являются объектами.»);
текстовая строка "В C# строки являются объектами." автоматически преобразуется в строковый объект средствами С#. Следовательно, применение класса типа string происходило в предыдущих примерах программ неявным образом. А в этом разделе будет показано, как обращаться со строками явным образом.
Построение строк
Самый простой способ построить символьную строку – воспользоваться строковым литералом. Например, в следующей строке кода переменной ссылки на строку str присваивается ссылка на строковый литерал.
string str = «Строки в C# весьма эффективны.»;
В данном случае переменная str инициализируется последовательностью символов «Строки в C# весьма эффективны.».
Объект типа string можно также создать из массива типа char. Например:
char[] charray = {'t', 'е', 's', 't'};
string str = new string(charray);
Как только объект типа string будет создан, его можно использовать везде, где только требуется строка текста, заключенного в кавычки. Как показано в приведенном ниже примере программы, объект типа string может служить в качестве аргумента при вызове метода WriteLine().
// Создать и вывести символьную строку.
using System;
class StringDemo {
static void Main() {
char[] charray ={'Э','т','o',' ','с','т','p','o','к','a',
'.'} ;
string strl = new string(charray);
string str2 = «Еще одна строка.»;
Console.WriteLine(strl);
Console.WriteLine(str2);
}
}
Результат выполнения этой программы приведен ниже.
Это строка.
Еще одна строка.
Обращение со строками
Класс типа string содержит ряд методов для обращения со строками. Некоторые из этих методов перечислены в табл. 7.1. Обратите внимание на то, что некоторые методы принимают параметр типа StringComparison. Это перечислимый тип, определяющий различные значения, которые определяют порядок сравнения символьных строк. (О перечислениях речь пойдет в главе 12, но для применения типа StringComparison к символьным строкам знать о перечислениях необязательно.) Нетрудно догадаться, что символьные строки можно сравнивать разными способами. Например, их можно сравнивать на основании двоичных значений символов, из которых они состоят. Такое сравнение называется порядковым. Строки можно также сравнивать с учетом различных особенностей культурной среды, например, в лексикографическом порядке. Это так называемое сравненение с учетом культурной среды. (Учитывать культурную среду особенно важно в локализуемых приложениях.) Кроме того, строки можно сравнивать с учетом или без учета регистра. Несмотря на то что существуют перегружаемые варианты методов Compare(), Equals(), IndexOf() и Last IndexOf(), обеспечивающие используемый по умолчанию подход к сравнению символьных строк, в настоящее время считается более приемлемым явно указывать способ требуемого сравнения, чтобы избежать неоднозначности, а также упростить локализацию приложений. Именно поэтому здесь рассматривают разные способы сравнения символьных строк.
Как правило и за рядом исключений, для сравнения символьных строк с учетом культурной среды (т.е. языковых и региональных стандартов) применяется способ StringComparison.CurrentCulture. Если же требуется сравнить строки только на основании значений их символов, то лучше воспользоваться способом StringComparison.Ordinal, а для сравнения строк без учета регистра – одним из двух способов: StringComparison.CurrentCulturelgnoreCase или StringComparison.OrdinallgnoreCase. Кроме того, можно указать сравнение строк без учета культурной среды (подробнее об этом – в главе 22).
Обратите внимание на то, что метод Compare() объявляется в табл. 7.1 как static. Подробнее о модификаторе static речь пойдет в главе 8, а до тех пор вкратце поясним, что он обозначает следующее: метод Compare() вызывается по имени своего класса, а не по его экземпляру. Следовательно, для вызова метода Compare() служит следующая общая форма:
результат = string.Compare(strl, str2, способ);
где способ обозначает конкретный подход к сравнению символьных строк.
–
ПРИМЕЧАНИЕ
Дополнительные сведения о способах сравнения и поиска символьных строк, включая и особое значение выбора подходящего способа, приведены в главе 22, где подробно рассматривается обработка строк.
–
Обратите также внимание на методы ToUpper() и ToLower(), преобразующие содержимое строки в символы верхнего и нижнего регистра соответственно. Их формы, представленные в табл. 7.1, содержат параметр CultureInfо, относящийся к классу, в котором описываются атрибуты культурной среды, применяемые для сравнения. В примерах, приведенных в этой книге, используются текущие настройки культурной среды (т.е. текущие языковые и региональные стандарты). Эти настройки указываются при передаче методу аргумента Culturelnfо.CurrentCulture. Класс Culturelnfо относится к пространству имен System.Globalization. Любопытно, имеются варианты рассматриваемых здесь методов, в которых текущая культурная среда используется по умолчанию, но во избежание неоднозначности в примерах из этой книги аргумент Culturelnfо.CurrentCulture указывается явно.
Объекты типа string содержат также свойство Length, где хранится длина строки.
Таблица 7.1. Некоторые общеупотребительные методы обращения со строками
Метод
Описание
static int Compare(string strA, string strB, StringComparison comparisonType)
Возвращает отрицательное значение, если строка strA меньше строки strB; положительное значение, если строка strA больше строки strB; и нуль, если сравниваемые строки равны. Способ сравнения определяется аргументом comparisonType
bool Equals(string value, StringComparison comparisonType)
Возвращает логическое значение true, если вызывающая строка имеет такое же значение, как и у аргумента value. Способ сравнения определяется аргументом comparisonType
int IndexOf(char value)
Осуществляет поиск в вызывающей строке первого вхождения символа, определяемого аргументом value. Применяется порядковый способ поиска. Возвращает индекс первого совпадения с искомым символом или -1, если он не обнаружен.
int IndexOf(string value, StringComparison comparisonType)
Осуществляет поиск в вызывающей строке первого вхождения подстроки, определяемой аргументом value. Возвращает индекс первого совпадения с искомой подстрокой или -1, если она не обнаружена. Способ поиска определяется аргументом comparisonType
int LastlndexOf(char value)
Осуществляет поиск в вызывающей строке последнего вхождения символа, определяемого аргументом value. Применяется порядковый способ поиска. Возвращает индекс последнего совпадения с искомым символом или -1, если он не обнаружен
int LastlndexOf(string value, StringComparison comparisonType)
Осуществляет поиск в вызывающей строке последнего вхождения подстроки, определяемой аргументом value. Возвращает индекс последнего совпадения с искомой подстрокой или -1, если она не обнаружена. Способ поиска определяется аргументом comparisonType
string ToLower(Culturelnfo. CurrentCulture culture)
Возвращает вариант вызывающей строки в нижнем регистре. Способ преобразования определяется аргументом culture
string ToUpper(Culturelnfo. CurrentCulture culture)
Возвращает вариант вызывающей строки в верхнем регистре. Способ преобразования определяется аргументом culture
Отдельный символ выбирается из строки с помощью индекса, как в приведенном ниже фрагменте кода.
string str = «тест»;
Console.WriteLine(str[0] ) ;
В этом фрагменте кода выводится символ "т", который является первым в строке «тест». Как и в массивах, индексирование строк начинается с нуля. Следует, однако, иметь в виду, что с помощью индекса нельзя присвоить новое значение символу в строке. Индекс может служить только для выборки символа из строки.
Для проверки двух строк на равенство служит оператор ==. Как правило, если оператор == применяется к ссылкам на объект, то он определяет, являются ли они ссылками на один и тот же объект. Совсем иначе обстоит дело с объектами типа string. Когда оператор == применяется к ссылкам на две строки, он сравнивает содержимое этих строк. Это же относится и к оператору !=. В обоих случаях выполняется порядковое сравнение. Для проверки двух строк на равенство с учетом культурной среды служит метод Equals(), где непременно нужно указать способ сравнения в виде аргумента StringComparison.CurrentCulture. Следует также иметь в виду, что метод Compare() служит для сравнения строк с целью определить отношение порядка, например для сортировки. Если же требуется проверить символьные строки на равенство, то для этой цели лучше воспользоваться методом Equals() или строковыми операторами.
В приведенном ниже примере программы демонстрируется несколько операций со строками.
// Некоторые операции со строками.
using System;
using System.Globalization;
class StrOps {
static void Main() {
string strl = «Программировать в .NET лучше всего на С#.»;
string str2 = «Программировать в .NET лучше всего на С#.»;
string str3 = «Строки в C# весьма эффективны.»;
string strUp, strLow;
int result, idx;
Console.WriteLine("strl: " + strl);
Console.WriteLine("Длина строки strl: " + strl.Length);
// Создать варианты строки strl, набранные
// прописными и строчными буквами.
strLow = strl.ToLower(CultureInfo.CurrentCulture);
strUp = strl.ToUpper (CultureInfo.CurrentCulture);
Console.WriteLine("Вариант строки strl, " +
"набранный строчными буквами:n " + strLow);
Console.WriteLine("Вариант строки strl, " +
"набранный прописными буквами:n " + strUp);
Console.WriteLine();
// Вывести строку strl посимвольно.
Console.WriteLine(«Вывод строки strl посимвольно.»);
for (int i=0; i < strl.Length; i++)
Console.Write(strl[i]);
Console.WriteLine(«n»);
// Сравнить строки способом порядкового сравнения,
if (strl == str2)
Console.WriteLine(«strl == str2»);
else
Console.WriteLine(«strl != str2»);
if (strl == str3)
Console.WriteLine(«strl == str3»);
else
Console.WriteLine(«strl != str3»);
// Сравнить строки с учетом культурной среды.
result = string.Compare(str3, strl, StringComparison.CurrentCulture) ;
if(result == 0)
Console.WriteLine(«Строки strl и str3 равны»);
else
if (result < 0)
Console.WriteLine(«Строка strl-меньше строки str3»);
else
Console.WriteLine(«Строка strl больше строки str3»);
Console.WriteLine();
// Присвоить новую строку переменной str2.
str2 = «Один Два Три Один»;
// Поиск подстроки.
idx = str2.IndexOf(«Один», StringComparison.Ordinal);
Console.WriteLine("Индекс первого вхождения подстроки <Один>: " + idx);
idx = str2.LastIndexOf(«Один», StringComparison.Ordinal);
Console.WriteLine("Индекс последнего вхождения подстроки <0дин>: " + idx) ;
}
}
При выполнении этой программы получается следующий результат.
strl: Программировать в .NET лучше всего на С#.
Длина строки str1: 41
Вариант строки str1, набранный строчными буквами:
программировать в .net лучше всего на с#.
Вариант строки str1, набранный прописными буквами:
программировать в .net лучше всего на с#.
Вывод строки str1 посимвольно.
Программировать в .NET лучше всего на С#.
str1 == str2
str1 != str3
Строка str1 больше строки str3
Индекс первого вхождения подстроки <0дин>: О
Индекс последнего вхождения подстроки <0дин>: 13
Прежде чем читать дальше, обратите внимание на то, что метод Compare() вызывается следующим образом.
result = string.Compare(strl, str3, StringComparison.CurrentCulture);
Как пояснялось ранее, метод Compare() объявляется как static, и поэтому он вызывается по имени, а не по экземпляру своего класса.
С помощью оператора + можно сцепить (т.е. объединить вместе) две строки. Например, в следующем фрагменте кода:
string str1 = «Один»;
string str2 = «Два»;
string str3 = «Три»;
string str4 = str1 + str2 + str3;
переменная str4 инициализируется строкой «ОдинДваТри».
И еще одно замечание: ключевое слово string является псевдонимом класса System. String, определенного в библиотеке классов для среды .NET Framework, т.е. оно устанавливает прямое соответствие с этим классом. Следовательно, поля и методы, определяемые типом string, относятся непосредственно к классу System.String, в который входят и многие другие компоненты. Подробнее о классе System.String речь пойдет в части II этой книги.
Массивы строк
Аналогично данным любого другого типа, строки могут быть организованы в массивы. Ниже приведен соответствующий пример.
// Продемонстрировать массивы строк.
using System;
class StringArrays {
static void Main() {
string[] str = { «Это», «очень», «простой», «тест.» };
Console.WriteLine("Исходный массив: ");
for (int i=0; i < str.Length; i++)
Console.Write(str[i] + " ");
Console.WriteLine(«n»);
// Изменить строку.
str[1] = «тоже»;
str[3] = «до предела тест!»;
Console.WriteLine("Видоизмененный массив: ");
for (int i=0; i < str.Length; i++)
Console.Write(str[i] + " ");
}
}
Вот какой результат дает выполнение приведенного выше кода.
Исходный массив:
Это очень простой тест.
Видоизмененный массив:
Это тоже простой до предела тест!
Рассмотрим более интересный пример. В приведенной ниже программе целое число выводится словами. Например, число 19 выводится словами «один девять».
// Вывести отдельные цифры целого числа словами, using System;
class ConvertDigitsToWords {
static void Main() {
int num;
int nextdigit;
int numdigits;
int[] n = new int[20];
string[] digits = { «нуль», «один», «два»,
«три», «четыре», «пять»,
«шесть», «семь», «восемь»,
«девять» };
num =1908;
Console.WriteLine("Число: " + num);
Console.Write("Число словами: ");
nextdigit = 0; numdigits = 0;
// Получить отдельные цифры и сохранить их в массиве п.
// Эти цифры сохраняются в обратном порядке,
do {
nextdigit = num % 10;
n[numdigits] = nextdigit;
numdigits++;
num = num /10;
} while(num > 0);
numdigits–;
// Вывести полученные слова.
for( ; numdigits >= 0; numdigits–)
Console.Write(digits[n[numdigits]] + " ");
Console.WriteLine() ;
}
}
Выполнение этой программы приводит к следующему результату.
Число: 1908
Число словами: один девять нуль восемь
В данной программе использован массив строк digits для хранения словесных обозначений цифр от 0 до 9. По ходу выполнения программы целое число преобразуется в слова. Для этого сначала получаются отдельные цифры числа, а затем они сохраняются в обратном порядке следования в массиве n типа int. После этого выполняется циклический опрос массива n в обратном порядке. При этом каждое целое значение из массива n служит в качестве индекса, указывающего на слова, соответствующие полученным цифрам числа и выводимые как строки.
Постоянство строк
Как ни странно, содержимое объекта типа string не подлежит изменению. Это означает, что однажды созданную последовательность символов изменить нельзя. Но данное ограничение способствует более эффективной реализации символьных строк. Поэтому этот, на первый взгляд, очевидный недостаток на самом деле превращается в преимущество. Так, если требуется строка в качестве разновидности уже имеющейся строки, то для этой цели следует создать новую строку, содержащую все необходимые изменения. А поскольку неиспользуемые строковые объекты автоматически собираются в «мусор», то о дальнейшей судьбе ненужных строк можно даже не беспокоиться.
Следует, однако, подчеркнуть, что переменные ссылки на строки (т.е. объекты типа string) подлежат изменению, а следовательно, они могут ссылаться на другой объект. Но содержимое самого объекта типа string не меняется после его создания.
Для того чтобы стало понятнее, почему неизменяемые строки не являются помехой, воспользуемся еще одним методом обращения со строками: Substring(). Этот метод возвращает новую строку, содержащую часть вызывающей строки. В итоге создается новый строковый объект, содержащий выбранную подстроку, тогда как исходная строка не меняется, а следовательно, соблюдается принцип постоянства строк. Ниже приведена рассматриваемая здесь форма метода Substring():
string Substring(int индекс_начала, int длина)
где индекс_начала обозначает начальный индекс исходной строки, а длина — длину выбираемой подстроки.
Ниже приведена программа, в которой принцип постоянства строк демонстрируется на примере использования метода Substring().
// Применить метод Substring().
using System;
class SubStr {
static void Main() {
string orgstr = «В C# упрощается обращение со строками.»;
// сформировать подстроку
string substr = orgstr.Substring(5, 20);
Console.WriteLine("orgstr: " + orgstr);
Console.WriteLine("substr: " + substr);
}
}
Вот к какому результату приводит выполнение этой программы.
orgstr: В C# упрощается обращение со строками,
substr: упрощается обращение
Как видите, исходная строка из переменной orgstr не меняется, а выбранная из нее подстрока содержится в переменной substr.
И последнее замечание: несмотря на то, что постоянство строк обычно не является ни ограничением, ни помехой для программирования на С#, иногда оказывается полезно иметь возможность видоизменять строки. Для этой цели в С# имеется класс StringBuilder, который определен в пространстве имен System.Text. Этот класс позволяет создавать строковые объекты, которые можно изменять. Но, как правило, в программировании на C# используется тип string, а не класс StringBuilder.
Применение строк в операторах switch
Объекты типа string могут использоваться для управления оператором switch. Это единственный нецелочисленный тип данных, который допускается применять в операторе switch. Благодаря такому применению строк в некоторых сложных ситуациях удается найти более простой выход из положения, чем может показаться на первый взгляд. Например, в приведенной ниже программе выводятся отдельные цифры, соответствующие словам «один», «два» и «три».
// Продемонстрировать управление оператором switch посредством строк.
using System;
class StringSwitch {
static void Main() {
string[] strs = { «один», «два», «три», «два», «один» };
