Работа со строками c windows forms

Операции со строками

Последнее обновление: 05.01.2022

Объединение строк

Конкатенация строк или объединение может производиться как с помощью операции +, так и с помощью метода Concat:

string s1 = "hello";
string s2 = "world";
string s3 = s1 + " " + s2; // результат: строка "hello world"
string s4 = string.Concat(s3, "!!!"); // результат: строка "hello world!!!"

Console.WriteLine(s4);

Метод Concat является статическим методом класса string, принимающим в качестве параметров две строки. Также имеются другие версии
метода, принимающие другое количество параметров.

Для объединения строк также может использоваться метод Join:

string s5 = "apple";
string s6 = "a day";
string s7 = "keeps";
string s8 = "a doctor";
string s9 = "away";
string[] values = new string[] { s5, s6, s7, s8, s9 };

string s10 = string.Join(" ", values);
Console.WriteLine(s10); // apple a day keeps a doctor away

Метод Join также является статическим. Использованная выше версия метода получает два параметра: строку-разделитель (в данном случае пробел) и
массив строк, которые будут соединяться и разделяться разделителем.

Сравнение строк

Для сравнения строк применяется статический метод Compare:

string s1 = "hello";
string s2 = "world";

int result = string.Compare(s1, s2);
if (result<0)
{
    Console.WriteLine("Строка s1 перед строкой s2");
}
else if (result > 0)
{
    Console.WriteLine("Строка s1 стоит после строки s2");
}
else
{
    Console.WriteLine("Строки s1 и s2 идентичны");
}
// результатом будет "Строка s1 перед строкой s2"

Данная версия метода Compare принимает две строки и возвращает число. Если первая строка по алфавиту стоит выше второй, то возвращается число меньше нуля.
В противном случае возвращается число больше нуля. И третий случай — если строки равны, то возвращается число 0.

В данном случае так как символ h по алфавиту стоит выше символа w, то и первая строка будет стоять выше.

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

С помощью метода IndexOf мы можем определить индекс первого вхождения отдельного символа или подстроки в строке:

string s1 = "hello world";
char ch = 'o';
int indexOfChar = s1.IndexOf(ch); // равно 4
Console.WriteLine(indexOfChar);

string substring = "wor";
int indexOfSubstring = s1.IndexOf(substring); // равно 6
Console.WriteLine(indexOfSubstring);

Подобным образом действует метод LastIndexOf, только находит индекс последнего вхождения символа или подстроки в строку.

Еще одна группа методов позволяет узнать начинается или заканчивается ли строка на определенную подстроку. Для этого предназначены методы
StartsWith и EndsWith. Например, в массиве строк хранится список файлов, и нам надо вывести все файлы с
расширением exe:

var files = new string[]
{
    "myapp.exe",
    "forest.jpg",
    "main.exe",
    "book.pdf",
    "river.png"
};

for (int i = 0; i < files.Length; i++)
{
    if (files[i].EndsWith(".exe"))
        Console.WriteLine(files[i]);
}

Разделение строк

С помощью функции Split мы можем разделить строку на массив подстрок. В качестве параметра функция Split
принимает массив символов или строк, которые и будут служить разделителями. Например, подсчитаем количество слов в сроке,
разделив ее по пробельным символам:

string text = "И поэтому все так произошло";

string[] words = text.Split(new char[] { ' ' });

foreach (string s in words)
{
    Console.WriteLine(s);
}

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

string[] words = text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

Второй параметр StringSplitOptions.RemoveEmptyEntries говорит, что надо удалить все пустые подстроки.

Обрезка строки

Для обрезки начальных или концевых символов используется функция Trim:

string text = " hello world ";

text = text.Trim(); // результат "hello world"
text = text.Trim(new char[] { 'd', 'h' }); // результат "ello worl"

Функция Trim без параметров обрезает начальные и конечные пробелы и возвращает обрезанную строку. Чтобы явным образом указать, какие
начальные и конечные символы следует обрезать, мы можем передать в функцию массив этих символов.

Эта функция имеет частичные аналоги: функция TrimStart обрезает начальные символы, а функция TrimEnd обрезает конечные символы.

Обрезать определенную часть строки позволяет функция Substring:

string text = "Хороший день";
// обрезаем начиная с третьего символа
text = text.Substring(2);
// результат "роший день"
Console.WriteLine(text);
// обрезаем сначала до последних двух символов
text = text.Substring(0, text.Length - 2);
// результат "роший де"
 Console.WriteLine(text);

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

Вставка

Для вставки одной строки в другую применяется функция Insert:

string text = "Хороший день";
string substring = "замечательный ";

text = text.Insert(8, substring);
Console.WriteLine(text);	// Хороший замечательный день

Первым параметром в функции Insert является индекс, по которому надо вставлять подстроку, а второй параметр — собственно подстрока.

Удаление строк

Удалить часть строки помогает метод Remove:

string text = "Хороший день";
// индекс последнего символа
int ind = text.Length - 1;
// вырезаем последний символ
text = text.Remove(ind); 
Console.WriteLine(text);    // Хороший ден

// вырезаем первые два символа
text = text.Remove(0, 2);
Console.WriteLine(text);    // роший ден

Первая версия метода Remove принимает индекс в строке, начиная с которого надо удалить все символы. Вторая версия принимает еще один параметр — сколько
символов надо удалить.

Замена

Чтобы заменить один символ или подстроку на другую, применяется метод Replace:

string text = "хороший день";

text = text.Replace("хороший", "плохой");
Console.WriteLine(text);	// плохой день

text = text.Replace("о", "");
Console.WriteLine(text);	// плхй день

Во втором случае применения функции Replace строка из одного символа «о» заменяется на пустую строку, то есть фактически удаляется из текста.
Подобным способом легко удалять какой-то определенный текст в строках.

Смена регистра

Для приведения строки к верхнему и нижнему регистру используются соответственно функции ToUpper() и
ToLower():

string hello = "Hello world!";

Console.WriteLine(hello.ToLower()); // hello world!
Console.WriteLine(hello.ToUpper()); // HELLO WORLD!

Тема работы со строками является одной из значимых при изучении любого языка программирования. В приведенном материале будут рассмотрены как базовые концепции работы со строками, так и расширенные возможности, предоставляемые C#.

• Знакомство со строками в C#
• Создание и инициализация объекта класса String
• Базовый API для работы со строками
  • Объединение строк. Оператор +, методы Concat и Join
  • Поиск и извлечение элементов из строки. Оператор [], методы IndexOf, IndexOfAny, LastIndexOf, LastIndexOfAny, Substring
  • Сравнение срок
  • Модификация срок
  • Методы и свойства общего назначения
• Форматирование строк
  • Представление чисел
  • Представление даты и времени
• $ — интерполяция строк
• Управляющие символы (литералы)
• @ – буквальный идентификатор
• Класс StringBuilder

Исходный код примеров из этой статьи можете скачать из нашего github-репозитория.

За представление строк в C# отвечает класс System.String. В коде, для объявления переменной соответствующего типа, предпочтительно использовать следующий вариант написания: string – с маленькой буквы. Это ключевое слово языка, используя которое можно объявлять строковые переменные, также как int является псевдонимом для  System.Int32, а bool – для System.Boolean.

string s1 = "Hello, World!";
Console.WriteLine(s1);

Допустимо объявление строковых переменных через ключевое слово var:

var s2 = "Create by var";
Console.WriteLine(s2);

Для объединения строк используется оператор +:

string s3 = "Hello, ";
string s4 = s3 + "John!";
Console.WriteLine(s4);

При работе со String следует помнить, что при переопределении значения переменной создается новый экземпляр строковой переменной в памяти. Поэтому, если вам нужно собрать строку из большого количества составляющих, то использование оператора + не самый лучший вариант. В этом случае будет происходить перерасход памяти: при выполнении операции объединения с присваиванием для очень большого количества подстрок, приложение может аварийно завершиться из-за того, что сборщик мусора не будет успевать удалять неиспользуемые объекты, а новые будут продолжать появляться с большой скоростью. Для решения этой задачи используйте StringBuilder, о нем будет рассказано в конце этого урока.

Создание и инициализация объекта класса String

Существует несколько способов создать объект класса String и проинициализировать его. Рассмотрим варианты, которые доступны в C#. Наиболее распространенный способ сделать эту операцию – это присвоить строковое значение переменной без явного вызова конструктора, так, как мы это делали в предыдущем разделе:

string s5 = "test1";
var s6 = "test2";

Для дословного представления строки, для того чтобы проигнорировать управляющие последовательности, используйте префикс @ перед значением. Сравните вывод следующей конструкции:

Console.WriteLine("first linenSecond line");

С вариантом:

Console.WriteLine(@"first linenSecond line");

Если требуется подготовить строковое значение с использованием набора переменных, то можно воспользоваться статическим методом Format класса String, либо префиксом $:

int age = 27;
Console.WriteLine(String.Format("Age: {0}", age));
Console.WriteLine("");
Console.WriteLine($"Age: {age}");
Console.WriteLine("");

Можно явно вызвать конструктор типа c передачей в него параметров. Самый простой вариант – это передать строку:

string s7 = new string("test3");

В качестве параметра может выступать массив Char элементов:

char[] charArray = {'H', 'e', 'l', 'l', 'o'};
string s8 = new string(charArray);

Ещё вариант – это указать элемент типа char и количество раз, которое его нужно повторить:

string s9 = new string('O', 10); // "OOOOOOOOOO"

Для создания строки также можно использовать указатели на Char* и SByte*, но в данном уроке эта тема рассматриваться не будет.

Базовый API для работы со строками

В рамках данного раздела рассмотрим наиболее интересные и полезные методы и свойства класса String.

Объединение строк. Оператор +, методы Concat и Join

Сцеплять строки между собой можно с помощью оператора +, при этом, в результате объединения, будет создан новый объект:

string s10 = "Area";
string s11 = " 51";
Console.WriteLine("Concat by +: " + s10 + s11);

В составе API, который предоставляет System.String, есть метод Concat, который может выполнять ту же работу:

Console.WriteLine("Concat by Concat(): " + string.Concat(s10, s11));

Метод Concat позволяет объединить до четырех строк через прямое перечисление. Если нужно таким образом объединить больше строковых переменных и значений, то используйте оператор +. Полезным свойством Concat является то, что он может принять на вход массив элементов типа String  и объединить их:

string[] sArr1 = {"First ", "Second ", "Third "};
Console.WriteLine(string.Concat(sArr1));

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

string[] sArr2 = {"First", "Second", "Third"};
Console.WriteLine("Join elements in array by Join() with space: " + string.Join(" ", sArr2));

В качестве разделителя можно использовать любую строку:

Console.WriteLine("Join elements in array by Join() with <->: " + string.Join("<->", sArr2));

Поиск и извлечение элементов из строки. Оператор [], методы IndexOf, IndexOfAny, LastIndexOf, LastIndexOfAny, Substring

Для получения символа из строки с конкретной позиции можно использовать синтаксис подобный тому, что применяется при работе с массивами – через квадратные скобки []:

string s12 = "Hello";
Console.WriteLine("Get element by index s12[3]: " + s12[3]);

Для решения обратной задачи: поиск индекса первого (последнего) вхождения элемента или сроки в данной строке используются методы IndexOf, IndexOfAny и LastIndexOf, LastIndexOfAny.

В таблице ниже перечислены некоторые из предоставляемых System.String вариантов этих методов.

// s1 = "Hello, World!"
// Поиск первого вхождения символа 'r'
Console.WriteLine("Index of 'r': " + s1.IndexOf('r'));
// Поиск первого вхождения символа 'l' начиная с позиции 4
Console.WriteLine("Index of 'l', start at 4: " + s1.IndexOf('l', 4));
// Поиск первого вхождения строки "World"
Console.WriteLine("Index of "World": " + s1.IndexOf("World"));
// Поиск первого вхождения символа из набора ['o', 'd', ',']
Console.WriteLine("Index of pos of any symbol in array: " + s1.IndexOfAny(new char[] {'o', 'd', ','}));

// Поиск последнего вхождения символа 'l'
Console.WriteLine("Last index of 'l': " + s1.LastIndexOf('l'));
// Поиск последнего вхождения строки "or"
Console.WriteLine("Last index of "or": " + s1.LastIndexOf("or"));
// Поиск последнего вхождения символа из набора ['o', 'd', ',']
Console.WriteLine("Last index of pos of any symbol in array: " + s1.LastIndexOfAny(new char[] {'o', 'd', ','}));

Для определения того, содержит ли данная строка указанную подстроку, а также для проверки равенства начала или конца строки заданному значению используйте методы: Contains, StartsWith и EndsWith.

Console.WriteLine("Contains "World"? " + s1.Contains("World")); // True
Console.WriteLine("Starts with "He"? " + s1.StartsWith("He")); // True
Console.WriteLine("Ends with "ld"? " + s1.EndsWith("ld")); // False

Задачу извлечения подстроки из данной строки решает метод SubString:

Console.WriteLine("Substring start at pos 7: " + s1.Substring(7));  // World!
Console.WriteLine("Substring start at pos 7 (4 chars): " + s1.Substring(7, 4)); // Worl

Сравнение срок

Для сравнения строк можно использовать оператор сравнения ==, при этом будут сравниваться значения строковых переменных, а не их ссылки, как это делается для других ссылочных типов.

string t1 = "John";
string t2 = "John";
string t3 = "Mary";
Console.WriteLine("t1 == t2: " + (t1 == t2));   // True
Console.WriteLine("t1 != t2: " + (t1 != t2));   // False
Console.WriteLine("t1 == t3: " + (t1 == t3));   // False

Для сравнения также можно использовать метод Equals, но это менее удобный вариант:

Console.WriteLine("Equals method: t1.Equals(t2)" + t1.Equals(t2));   // True
Console.WriteLine("Equals method: t1.Equals(t3)" + t1.Equals(t3));   // False

Модификация срок

Класс String предоставляет довольно большое количество инструментов для изменения строк. 

Вставка строки в исходную в заданную позицию осуществляется с помощью метода Insert:

Console.WriteLine("Insert: " + "26".Insert(1, "[4]")); // 2[4]6

Для приведения строки к заданной длине с выравниванием по левому (правому) краю с заполнением недостающих символов пробелами используются методы PadLeft и PadRight:

Console.WriteLine("PadLeft: ");
Console.WriteLine("some string".PadLeft(15)); // "    some string"
Console.WriteLine("some string".PadLeft(15, '*')); // "****some string"
Console.WriteLine("PadRight: ");
Console.WriteLine("some string".PadRight(15)); // "some string    "
Console.WriteLine("some string".PadRight(15, '*')); // "some string****"

Метод Remove удаляет подстроку из исходной строки. Возможны два варианта использования:

Console.WriteLine("Remove demo1: " + "Hello".Remove(2));
Console.WriteLine("Remove demo2: " + "Hello".Remove(2, 2));

Замена элементов строки производится с помощью метода Replace. Наиболее часто используемые варианты – это замена символа на символ и строки на подстроку:

Console.WriteLine("Hello, World!".Replace('!', '.')); // Hello, World.
Console.WriteLine("Hello, World!".Replace("World", "John")); // Hello, John!

Для преобразования строки к верхнему регистру используйте метод ToUpper(), к нижнему – ToLower():

Console.WriteLine("Hello, World!".ToUpper()); // HELLO, WORLD!
Console.WriteLine("Hello, World!".ToLower()); // hello, world!

За удаление начальных и конечных символов отвечают методы, начинающиеся на Trim (см. таблицу ниже).

Console.WriteLine("   hello   ".Trim());    // "hello"
Console.WriteLine("***hello---".Trim('*'));    // "hello---"
Console.WriteLine("***hello---".Trim(new char[] {'*', '-'}));    // "hello"
Console.WriteLine("   hello   ".TrimStart());   // "hello   "           
Console.WriteLine("   hello   ".TrimEnd()); // "   hello"

Методы и свойства общего назначения

Рассмотрим некоторые из полезных методов и свойств, которые не вошли в приведенные выше группы.

System.Length – возвращает длину строки:

Console.WriteLine("Hello".Length); // 5

System.Split() – разделяет заданную строку на подстроки, в качестве разделителя используется указанный через параметр символ (или группа символов):

foreach(var s in "1 2 3".Split(' '))
Console.WriteLine(s);

foreach(var s in "1 2 3-4-5-6".Split(new char[]{' ', '-'}))
Console.WriteLine(s);

System.Empty – возвращает пустую строку.

Форматирование строк

Под форматированием строк, в рамках данного раздела, понимается встраивание в строку различных элементом  (число, дата и т.п.), представленных в заданном формате. Форматирование можно осуществлять с помощью метода ToString с передачей в него нужных описателей, метода Format, который, в качестве аргументов, получает строку со специальными вставками, определяющими представление элементов и непосредственно сами элементы.

Для начала рассмотрим на нескольких примерах работу с этими методоми:

// ToString
Console.WriteLine(12345.ToString("X"));


// String.Format
Console.WriteLine(string.Format("value: {0}", 1.23456));
Console.WriteLine(string.Format("value: {0:F}", 1.23456));
Console.WriteLine(string.Format("value: {0:d}", 1.23456));
        

// WriteLine без использования String.Format
Console.WriteLine("value: {0}", 1.23456);   // 1,23456
Console.WriteLine("value: {0:F}", 1.23456); // 1.235
Console.WriteLine("date: {0:d}", DateTime.Now); // 07.09.2020

Эта функциональность также доступна для методов  StringBuilder.AppendFormat,  TextWriter.WriteLine,  Debug.WriteLine, методов из Trace, которые выводят текстовые сообщения, например: Trace.TraceError и метод TraceSource.TraceInformation.

Каждый элемент форматирования представляется следующим образом:

{index[,alignment][:formatString]}

где index – это индекс элемента, которым будет замещена данная конструкция;

alignment – выравнивание;

formatString – формат.

Ниже приведены примеры использования элементов форматирования:

Console.WriteLine("Only index: {0}", 123); // Only index: 123
Console.WriteLine("Index with alignment: {0,-5}{1,5}", 123, 456); // Index with alignment: 123    456
Console.WriteLine("Index with format: 0x{0:X}", 123); // Index with format: 0x7B

Представление чисел

Для представления чисел используются следующие описатели формата (список не полный, более детальную информацию можете найти в официальной документации):

Примеры использования описателей формата для чисел:

Console.WriteLine("C symbol: {0:C}", 123);      // 123,00 ₽
Console.WriteLine("D symbol: {0:D5}", 123);     // 00123
Console.WriteLine("E symbol: {0:E}", 123456789);// 1,234568E+008
Console.WriteLine("F symbol: {0:F2}", 123.4567);// 123,46
Console.WriteLine("P symbol: {0:P}", 0.123);    // 123,46
Console.WriteLine("X symbol: 0x{0:X}", 567);    // 0x237
Console.WriteLine("0 symbol: {0:000.00}", 12.6789);// 012,68
Console.WriteLine("# symbol: {0:##}", 14.6789); // 15

Представление даты и времени

Для представления даты и времени используются следующие описатели формата (список не полный, более детальную информацию можете найти в официальной документации):

Примеры использования описателей формата для даты и времени:

Console.WriteLine("d symbol: {0:d}", DateTime.Now);
Console.WriteLine("D symbol: {0:D}", DateTime.Now);
Console.WriteLine("f symbol: {0:f}", DateTime.Now);
Console.WriteLine("F symbol: {0:F}", DateTime.Now);
Console.WriteLine("g symbol: {0:g}", DateTime.Now);
Console.WriteLine("G symbol: {0:G}", DateTime.Now);
Console.WriteLine("t symbol: {0:t}", DateTime.Now);
Console.WriteLine("T symbol: {0:T}", DateTime.Now);
Console.WriteLine("{0:yyyy-MM-dd}", DateTime.Now);
Console.WriteLine("{0:dd/MM/yy}", DateTime.Now);
Console.WriteLine("{0:dd/MM/yy HH:mm:ss}", DateTime.Now);

$ — интерполяция строк

Начиная с C# 6 появилась возможность строить интерполированную строку, формат которой позволяет более просто, по сравнению с составным форматированием, рассмотренным нами выше, создавать строки. Интерполированная строка содержит специальные выражения интерполяции, они похожи на элементы форматирования. Выражения интерполяции имеют следующий вид:

{<interpolationExpression>[,<alignment>][:<formatString>]}

где interpolationExpression – элемент, значение, которого будет интегрироваться в строку;

alignment – выравнивание;

formatString – формат (см. форматирование строк).

Примеры работы с интерполированной строкой:

int n1 = 45678;
double d1 = 123.34567;
bool b1 = true;
string sv = "test";
Console.WriteLine($"int val: {n1}, double val: {d1:#.###}");
Console.WriteLine($"bool val: {b1}, string val: {sv}");

Управляющие символы (литералы)

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

Пример использования управляющих символов:

Console.WriteLine("aName:t"John"nAge:t"27"");

@ – буквальный идентификатор

Еще один элемент, который можно использовать при создании срок – это буквальный идентификатор @. Если его поставить перед строкой, то она будет интерпретироваться буквально, в ней, escape-последовательности представляются без преобразования.

Пример работы с буквальным идентификатором:

Console.WriteLine(@"escape is not work: atnx1234");

Класс StringBuilder

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

Если для построения итоговой строки использовать оператор +, как это сделано в примере ниже, то при выполнении операции += каждый раз будет создавать новый объект класса String в памяти. Если количество таких присваиваний будет достаточно большим, то программа может аварийно завершиться из-за нехватки памяти, либо занять ее в очень большом объеме. Это происходит из-за того, что сборщик мусора не будет успевать уничтожать неиспользуемые объекты, которые создаются с большой скоростью. Пример реализации с использованием оператора +:

string outString = "";
for(int i = 0; i < 10; i++)
{
   outString += i.ToString() + " - ";
}
Console.WriteLine(outString);

Более эффективным решением будет использование StringBuilder:

StringBuilder sb = new StringBuilder();
for(int i = 0; i < 10; i++)
{
    sb.Append(i.ToString());
    sb.Append(" - ");
}
outString = sb.ToString();
Console.WriteLine(outString);

Исходный код примеров из этой статьи можете скачать из нашего github-репозитория.

В предыдущей статье мы рассмотрели основные моменты, касающиеся работы со строками в C#: создание строк, неизменность строк, использование регулярных и буквальных литералов в строках и так далее. Сегодня мы продолжим разбираться с этой важной и довольно интересной темой и рассмотрим основные методы работы со строками в C#.

Функциональность класса System.String наиболее полно раскрывается через его методы, основными из которых являются следующие:

• Compare — сравнивает две строки с учетом текущих региональных настроек (локали) пользователя
• CompareOrdinal— сравнивает две строки без учета локали
• Contains— проверяет, содержится ли заданная подстрока в строке
• Concat— объединяет строки
• CopyTo— копирует часть строки, начиная с определенного индекса, в массив
• EndsWith— проверяет совпадает ли конец строки с подстрокой
• Format— форматирует строку
• IndexOf— находит индекс первого вхождения символа или подстроки в строке
• Insert— вставляет в строку подстроку
• Join— соединяет элементы массива строк
• LastIndexOf— находит индекс последнего вхождения символа или подстроки в строке
• Replace— заменяет в строке символ или подстроку другим символом или подстрокой
• Split— разделяет одну строку на массив строк
• Substring— извлекает из строки подстроку, начиная с указанной позиции
• ToLower— переводит все символы строки в нижний регистр
• ToUpper— переводит все символы строки в верхний регистр
• Trim— удаляет начальные и конечные пробелы из строки

Рассмотрим представленные методы более подробно.

Сравнение строк в C#

Для сравнения двух строк в C# удобно использовать метод Compare.

public static int Compare (string strA, string strB);

Результатом выполнения метода является целое число Int32. Это число означает следующее:

Например,

string s1 = "Строка";
string s2 = "Строка";
int res = string.Compare(s1, s2);
Console.WriteLine(res);

Вернет значение 0 так как строки равны.

У класса String есть также несколько перегруженных методов Compare, позволяющих провести настройку способа сравнения строк. Например, можно сравнивать строки, игнорируя регистр:

public static int Compare(String? strA, String? strB, bool ignoreCase);

или определить свои настройки сравнения строк, используя следующий вариант метода Compare:

public static int Compare(String? strA, String? strB, StringComparison comparisonType);

Несмотря на то, что метод Compare по умолчанию предназначен для сравнения строк с учётом локали, используя перегруженные версии метода, можно сравнивать строки и без учёта региональных настроек, например, воспользовавшись вот таким способом:

string.Compare(s1, s2, true, System.Globalization.CultureInfo.InvariantCulture);

Сравнение строк в C# без учёта региональных настроек

Метод CompareOrdinal сравнивает два объекта String, оценивая числовые значения соответствующих объектов Char в каждой строке. Результат выполнения метода такой же, как и у предыдущего метода Compare (см. таблицу выше).

Проверка вхождения подстроки в строку в C#

Метод Containsпроверяет, входит ли заданная подстрока в строку. Этот метод не статический, поэтому использовать его необходимо только после создания объекта, то есть следующим образом:

string s1 = "Строка";
string s2 = "ока";

if (s1.Contains(s2))
{
    Console.WriteLine($"Строка {s1} содержит подстроку {s2}");
}
else
{
    Console.WriteLine($"Строка {s1} не содержит подстроку {s2}");
}

В примере выше мы проверяем содержится ли подстрока "ока" в строке "Строка". Очевидно, что результатом выполнения метода будет true.

Объединение строк в C# (конкатенация строк)

Для объединения строк в C# удобно использовать метод Concat. Этот метод принимает два или более параметров, позволяя объединять не только строки, но и строковые представления любых объектов. Например:

string s1 = "Hello";
string s2 = " world";
string s3 = string.Concat(s1, s2);
Console.WriteLine(s3);

Также возможно объединять и массивы строк:

string[] strArr = new string[3] { "Это", "массив", "строк" };
string s4 = string.Concat(strArr);
Console.WriteLine(s4);

Объединение строк с использованием разделителя в C#

Для того, чтобы объединить несколько строк с использованием заданного разделителе, в C# используется метод Join. В качестве входных параметров метод Join принимает массив или коллекцию строк и символ-разделитель, например:

string[] strArr = new string[3] { "Это", "массив", "строк" };
string s5 = string.Join('|', strArr);
Console.WriteLine(s5);

Для приведенного выше примера в консоли мы получим следующую объединенную строку:

Копирование строк в C#

Для копирования строк в C# можно воспользоваться не статическим методом CopyTo. Этот метод копирует из строки часть символов, начиная с заданной позиции, и вставляет их в массив символов, также с указанной позиции. Сигнатура метода следующая:

(int sourceIndex, char[] destination, int destinationIndex, int count);

Для того, чтобы продемонстрировать работу метода, воспользуемся следующим примером:

char[] charArr = new char[] { 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd' };
string s6 = "string";
s6.CopyTo(2, charArr, 0, 4);
Console.WriteLine(charArr);

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

В этом примере из строки s6 копируется 4 символа, начиная с символа с индексом 2 (так как нумерация начинается с нуля, то первый копируемый символ r) и вставляется в массив charArr, начиная с первого элемента (с индексом 0)

Также можно воспользоваться статическим методом Copy для создания полной копии строки:

string s6 = "string";
string s7 = string.Copy(s6);
Console.WriteLine(s7);

Проверка совпадения строк в C#

Достаточно часто при работе со строками приходится проверять вхождение одной подстроки в другую. Для выполнения проверки совпадения строк и подстрок в C# можно воспользоваться двумя методами:

public bool EndsWith(String value);
public bool StartsWith(String value);

Первый метод (EndWith) проверяет заканчивается ли проверяемая строка подстрокой value, а второй, соответственно, проводит проверку на наличие подстроки value в начале строки. Оба метода имеют перегрузки. Пример:

string s6 = "string";
if (s6.StartsWith("str"))
    Console.WriteLine("Найдено совпадение подстроки "str" в начале строки");
if (s6.EndsWith("ing"))
    Console.WriteLine("Найдено совпадение подстроки "ing" в конце строки");

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

Помимо использования регулярных и буквальных литералов при работе со строками, мы также можем создавать строки в C# используя метод Format. Для того, чтобы раскрыть все возможности форматирования строк, думаю, что потребуется написать отдельную статью. Сейчас же я просто продемонстрирую некоторые основные возможности использования этого метода.

double value = 7.123456789;
double value2 = 7.12;
string s8 = string.Format("Строка для форматирования. Первое число {0},  второе число {1}", value, value2);
Console.WriteLine(s8);

Результатом будет следующая строка:

Поиск в строках C#

Ещё одной частой задачей при работе со строками в C# является поиск символов и подстрок в строках. Поиск в строке можно осуществить, в том числе, с использованием метода IndexOf, имеющего несколько перегрузок:

public int IndexOf(String value, StringComparison comparisonType);
public int IndexOf(String value, int startIndex, StringComparison comparisonType);
public int IndexOf(String value, int startIndex, int count, StringComparison comparisonType);
public int IndexOf(String value, int startIndex, int count);
public int IndexOf(String value);
public int IndexOf(char value, StringComparison comparisonType);
public int IndexOf(char value, int startIndex, int count);
public int IndexOf(char value, int startIndex);
public int IndexOf(char value);

Этот метод возвращает индекс первого вхождения указанного символа или подстроки в строку. Например,

string s9 = "Строка для поиска символов и подстрок";
int index = s9.IndexOf("о");
if (index > -1)
    Console.WriteLine("Индекс первого вхождения символа в строку {0}", index);
index = s9.IndexOf("сим");
if (index > -1)
    Console.WriteLine("Индекс первого символа искомой подстроки {0}", index);

Результатом выполнения будут следующие строки в консоли:

Соответственно, чтобы найти последнее вхождение символа или подстроки в строку, достаточно воспользоваться методом:

public int LastIndexOf(char value, int startIndex, int count);
public int LastIndexOf(char value, int startIndex);
public int LastIndexOf(String value, StringComparison comparisonType);
public int LastIndexOf(String value, int startIndex, StringComparison comparisonType);
public int LastIndexOf(char value);
public int LastIndexOf(String value, int startIndex, int count);
public int LastIndexOf(String value, int startIndex);
public int LastIndexOf(String value);
public int LastIndexOf(String value, int startIndex, int count, StringComparison comparisonType);

Вставка подстроки в строку C#

Для вставки одной строки в другую в C# можно воспользоваться методом Insert:

public String Insert(int startIndex, String value);

Этот метод вставляет в строку, начиная с индекса startIndex подстроку value и возвращает в результате новый экземпляр строки. Например,

string s10 = "Hello ";
string s11 = s10.Insert(6, "world");
Console.WriteLine(s11);

Результат

Замена символов и подстрок в строках C#

Для замены символов и подстрок в строках C# используется метод Replace:

public String Replace(char oldChar, char newChar);
public String Replace(String oldValue, String? newValue);
public String Replace(String oldValue, String? newValue, bool ignoreCase, CultureInfo? culture);
public String Replace(String oldValue, String? newValue, StringComparison comparisonType);

Например, заменим все символы o с строке на символы А:

string s12 = "Исходная строка для замены всех символов о на символы А";
string s13 = s12.Replace('о', 'А');
Console.WriteLine(s13);

Результат

Разделение строк на подстроки в C#

Разделение строк на подстроки в C# также является достаточно частой задачей в программировании. Для этого можно воспользоваться методом Split

public String[] Split(String[]? separator, int count, StringSplitOptions options);
public String[] Split(String? separator, int count, StringSplitOptions options = StringSplitOptions.None);
public String[] Split(String[]? separator, StringSplitOptions options);
public String[] Split(char[]? separator, int count, StringSplitOptions options);
public String[] Split(String? separator, StringSplitOptions options = StringSplitOptions.None);
public String[] Split(char[]? separator, StringSplitOptions options);
public String[] Split(char separator, StringSplitOptions options = StringSplitOptions.None);
public String[] Split(params char[]? separator);
public String[] Split(char[]? separator, int count);
public String[] Split(char separator, int count, StringSplitOptions options = StringSplitOptions.None);

В качестве параметров метод Split принимает один или несколько символов (Char), используемых в качестве разделителя, а на выходе возвращает массив строк.  Рассмотрим работу метода Split на примере

string s14 = "Эта строка, которая будет разделена на подстроки с использованием двух разделителей";
string[] res = s14.Split(new char[] { ' ', ',' });
foreach (string s in res)
{
    Console.WriteLine(s);
}

Здесь в качестве разделителей мы используем два символа — пробел и запятую. Результатом выполнения кода будет следующий вывод в консоли:

Извлечение подстрок из строки в C#

Для извлечения подстрок из строки используется метод Substring:

public String Substring(int startIndex);
public String Substring(int startIndex, int length);

При использовании первого варианта метода (с одним параметром) из строки извлекается подстрока, начинающаяся с индекса startIndex и, при этом, извлечение происходит до конца строки. Во втором случае подстрока извлекается также, начиная с индекса startIndex, однако длина извлекаемой подстроки ограничивается вторым параметром — length.

Пример использования метода представлен ниже:

string s15 = "hello world";
string s16 = s15.Substring(6);
string s17 = s15.Substring(7, 3);
Console.WriteLine(s16);
Console.WriteLine(s17);

Результат выполнения

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

Для изменения регистра символов в строке в C# можно воспользоваться двумя методами:

public String ToLower();
public String ToLower(CultureInfo? culture);
public String ToUpper();
public String ToUpper(CultureInfo? culture);

Метод ToLower меняет регистр всех символов в строке на нижний, а метод ToUpper,  напротив — меняет регистр всех символов в строке на верхний. Пример

string s15 = "HelLo World";
string s16 = s15.ToLower();
string s17 = s15.ToUpper();
Console.WriteLine(s16);
Console.WriteLine(s17);

Результат выполнения

Обрезка строк в C#

Иногда требуется избавиться в строке от лишних символов в начале, в конце или одновременно и вначале и в конце. «Лишними» могут быть как обычные проблелы, так и прочие символы. Для обрезки строки в C# можно воспользоваться методами Trim*:

public String Trim();
public String Trim(char trimChar);
public String Trim(params char[]? trimChars);
public String TrimEnd(char trimChar);
public String TrimEnd(params char[]? trimChars);
public String TrimStart();
public String TrimStart(char trimChar);
public String TrimStart(params char[]? trimChars);

По названию метода можно понять смысл его работы. Так, если используется метод Trim(), то обрезка строки происходит и сначала и с конца, если же используется TrimEnd(), то строка обрезается только с конца. При этом, если используется версия метода без параметров, то из строки удаляются лидирующие или замыкающие пробелы, иначе — определенные в параметрах метода символы. Например,

string s15 = " HelLo World ";
string s16 = s15.Trim(); //обрезаем пробелы
string s17 = s16.Trim(new char[] {'H', 'd'}); //обрезаем заданные символы
Console.WriteLine(s16);
Console.WriteLine(s17);

Итого

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

Variables:

The variable is a container of information that can change its value. It provides the opportunity for:

Programming in C Sharp is related to the constant use of variables in which data is stored and processed.

Characteristics of the variables — the variables are characterized by:

A variable is a named memory area in which a value of a given type is available in the program under its name. Variables can be stored directly in the program memory (in the stack) or in the dynamic memory that stores larger objects (for example, character strings and arrays).

Naming a variable:

When we want the compiler to assign an area to the memory for some information used in our program, we need to assign a name to it. It serves as an identifier and allows us to refer to the required area of memory.

The name of the variables can be any of our choice, but we have to follow certain rules:

The following table lists all keywords in C #.

Strings:

Strings are a series of symbols. They are declared with the keyword string in C#. Their default value is null. Strings are enclosed in double quotes. Various word-processing operations can be performed on them: concatenation, separating by a separator, searching, substitution, and others.

Boolean expressions:

Boolean type is declared with the keyword bool. It has two values that can be accepted — true and false. The default value is false. It is most often used to store the result of calculating logical expressions.

Sample tasks:

1) Create Windows Forms Application which shows the cursor coordinates wen moving on the form. Logically separate the form to for quadrants, depending on that in which quadrant is the cursor, change the title of the form to: TopRight, TopLeft, BottomRight, BottomLeft.

Solutioin:

Create new Windows Form Application project.

Add Label control to the form and name it lCoords.

Double click on the form and in its Load event make the label control not visible:

private void Form1_Load(object sender, EventArgs e)
{
   lCoords.Visible = false;
}

From the form designer select the form go to properties, find and click on the Lightening sign to open the events menu. Find and double click on Mouse Move event:

In the generated event add the following code:

int xMousePoint, yMousePoint;

xMousePoint = e.X;
yMousePoint = e.Y;

lCoords.Text = "X: " + xMousePoint + "n Y: " + yMousePoint;
Point mousePoint = new Point(e.X + 12, e.Y + 12);
lCoords.Location = mousePoint;
lCoords.Show();

if (e.Y < this.Height / 2)
   this.Text = "Top";
else
   this.Text = "Bottom";

if (e.X < this.Width / 2)
   this.Text = this.Text + "Left";
else
   this.Text = this.Text + "Right";

This code captures cursor coordinates and writes them to the Text property of the Label. The location of the cursor is set to the label control so it can be positioned next to the cursor.

Checks are carried out in which part of the form the mouse cursor is and the corresponding text in the title of the form is displayed if the condition is fulfilled.

2) Create Windows Forms Application which shows the coordinates of the cursor in the title bar of the form. When the cursor is in one of the four angles of the form the title of the form to be changed as follows: Top Left corner or Top Right corner or Bottom Left corner or Bottom Right corner.

Solution:

Create new Windows application project.

Select the form, find and double click on the Mouse Move event. Add the following code to the event:

int xMousePoint, yMousePoint;

xMousePoint = e.X;
            yMousePoint = e.Y;

this.Text = "X: " + xMousePoint + "   Y: " + yMousePoint;
Point mousePoint = new Point(e.X + 12, e.Y + 12);

if (e.X == 0 && e.Y == 0)
   this.Text = "Top Left corner";

if (e.X == (this.Width - 17) && e.Y == 0)
   this.Text = "Top Right corner";

if (e.X == 0 && e.Y == (this.Width - 40))
   this.Text = "Bottom Left corner";

if (e.X == (this.Width - 17) && e.Y == (this.Width - 40))
   this.Text = "Bottom Right corner";

3) Create Windows Forms Application that performs the following string actions: exchange two words separated by a specific separator, validation of strings, regular expressions, anagrams and cryptogram.

Solution:

Create new Windows Forms Application project.

Design the form as shown on the picture:

In “GroupBox “String Functions” and name controls as shown:

Double click on the button, and its click event add the following code:

string ch;
string digits = "0123456789";
bool ok = true;

tbSocSecNum.Text = tbSocSecNum.Text.Replace("-", "");

if (tbSocSecNum.Text.Length < 9 || tbSocSecNum.Text.Length > 9)
   ok = false;
else
{
   int i = 0;

   while (i < 9)
   {
      ch = tbSocSecNum.Text.Substring(i, 1);

      if (!digits.Contains(ch))
         ok = false;

      i++;
   }
}
lSocSecNumShow.Text = ok.ToString();

The code checks if the entered value in the text box is number with nine characters length. If not a bool variable is set to false. If length is nine characters then a loop is created to check if each of the digits in the number is valid. If not valid then the bool variable ok is set to false. At the end the label text is set to the bool value.

In GrupBox „Regular Expressions” and name controls as shown:

— TextBox – tbSocNum;

— Label3 – lSocNum.

Select the TextBox control, find the KeyPress event and double click on it. Add the following code:

if (e.KeyChar == (char)Keys.Enter)
{
   string soc = tbSocNum.Text;
   Regex socReg = new Regex("[0-9]{9}");
   Match m = socReg.Match(soc);

   if (m.ToString() == soc)
      lSocNum.Text = soc + " - is А nvalid social security number";
   else
      lSocNum.Text = soc + " - is NOT a nvalid social security number";
}

The same check as above is done with regular expression.

In GrupBox „Anagrams” and name controls as shown:

Open the source code file and add the following functions under the form constructor.

private string[] SplitString(string sWord)
{
   int iI;
   string[] sLetters = new string[sWord.Length];

   for (iI = 0; iI < sWord.Length; iI++)
      sLetters[iI] = sWord.Substring(iI, 1);

   return sLetters;
}

private void Shuffle(string[] sLetters)
{
    int iI, iP;
    string sTemp;

    Random rndLetter =new Random();

    for (iI = 0; iI <= sLetters.Length - 1; iI++)
    {
        iP = rndLetter.Next(sLetters.Length);
        sTemp = sLetters[iI];
        sLetters[iI] = sLetters[iP];
        sLetters[iP] = sTemp;
    }
}

private string Compress(string[] sLetters)
{
   int iI;
   string sS = "";

   for (iI = 0; iI < sLetters.Length; iI++)
      sS = sS + sLetters[iI];

   return sS;
}

In the KeyPress event of the text box add the following code:

string[] sLetters;
string word = tbWord.Text;

if (e.KeyChar == (char)Keys.Enter)
{
   sLetters = SplitString(word);
   Shuffle(sLetters);
   lAnagram.Text = Compress(sLetters);
}

In GrupBox „Cryptograms” and name controls as shown:

Add the following function:

private string Scramble(string sS)
{
   int iI;
   char[] chChar;
   chChar = sS.ToCharArray();

   Random rndRandom = new Random();

   for (iI = 0; iI < chChar.Length; iI++)
   {
      int iRandom = rndRandom.Next(25);
      char chTemp = chChar[iI];
      chChar[iI] = chChar[iRandom];
      char check = chChar[iRandom];
      chChar[iRandom] = chTemp;
   }

   string sS2 = "";

   for (iI = 0; iI < chChar.Length; iI++)
      sS2 += chChar[iI];

   return sS2;
}

In the KeyPress event of the text box add the following code:

string sAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string sCode = Scramble(sAlphabet);
this.Text = sCode;
string sS = tbWords.Text;
sS = sS.ToUpper();

string sS2 = "";
int iI, iPos;

for (iI = 0; iI < sS.Length; iI++)
{
   string sChar = sS.Substring(iI, 1);
   iPos = sAlphabet.IndexOf(sChar);

   if (iPos >= 0)
      sS2 += sCode.Substring(iI, 1);
   else
      sS2 = sChar;
}
tbCryptogram.Text = sS2;

Self-assignments

1. Create Windows Forms Application “Age calculator” which calculates the age in years and mounts. Develop the application in two ways:

2. Create Windows Form Application “Guess the number” in which a random number is chosen every time the application is started. Construct the form with one TextBox control and one Button. When the user enters number and clicks the button, a validation I s made if the number is guessed correctly. If not guessed a direction is given to the user to try smaller or bigger number. If guessed a congratulation message is displayed.

3. Create Windows Form Application “String Manipulation” with the following possibilities: