Шаг 95.
Язык программирования C#. Начала
Работа с текстом. Создание текстового объекта (окончание)

    На этом шаге мы рассмотрим пример, иллюстрирующий различные способы создания такого объекта.

    Небольшой пример, в котором текстовые объекты создаются разными способами, представлен в примере ниже. 

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

namespace pr95_1
{
    class Program
    {
        static void Main()
        {
            // Символьный массив:
            char[] symbs = { 'Я', 'з', 'ы', 'к', ' ', 'C', '#' };
            Console.WriteLine("Символьный массив: ");
            // Отображение содержимого символьного массива:
            Console.WriteLine(symbs);
            // Текстовый объект создается
            // на основе символьного массива:
            String A = new String(symbs);
            // Проверка значения текстового объекта:
            Console.WriteLine("А: \"{0}\"", A);
            // Текстовый объект создается на основе 
            // нескольких элементов из символьного массива:
            String B = new String(symbs, 1, 5);
            // Проверка значения текстового объекта:
            Console.WriteLine("В: \"{0}\"", B);
            // Текстовый объект создается как 
            // последовательность одинаковых симзолов:
            String C = new String('ы', 7);
            // Проверка значения текстового объекта:
            Console.WriteLine("С: \"{0}\"", C);
            // Создание текстового объекта путем вызова 
            // статического метода с двумя символьными 
            // аргументами:
            A = getText('A', 'H');
            // Проверка значения текстового объекта:
            Console.WriteLine("А: \"{0}\"", A);
            // Создание текстового объекта путем вызова 
            // статического метода с двумя символьными 
            // аргументами:
            B = getText('H', 'A');
            // Проверка значения текстового объекта:
            Console.WriteLine("В: \"{0}\"", B);
            // Создание текстового объекта путем вызова 
            // статического метода с аргументом - символьным 
            // массивом:
            C = getText(symbs);
            // Проверка значения текстового объекта:
            Console.WriteLine("С: \"{0}\"", C);
            // Задержка:
            Console.ReadLine();
        }

        // Статический метод для создания текстового объекта 
        // на основе символьного массива: 
        static String getText(char[] symbs){
            // Локальная текстовая переменная:
            String txt = "";
            // Перебор элементов в массиве: 
            for(int k=0; k < symbs.Length; k++) {
                // Дописывание символа к текстовой строке: 
                txt += symbs[k];
            }
            // Результат метода: 
            return txt;
        }

        // Статический метод для создания текстового объекта 
        // на основе двух символьных значений: 
        static String getText(char a, char b) {
            // Локальная текстовая переменная:
            String txt = "";
            // Локальная символьная переменная: 
            char s = a;
            // Формирование текстовой строки: 
            while(s <= b) {
                // Дописывание символа к текстовой строке: 
                txt += s;
                // Следующий символ для строки: 
                s++;
            }
            // Результат метода: 
            return txt;
        }
    }
}
Архив проекта можно взять здесь.

    Результат выполнения программы представлен ниже.


Рис.1. Результат выполнения программы

    В программе мы несколькими способами создаем текстовые объекты и затем проверяем их значение (текст, содержащийся в этих объектах). Также в программе описывается две версии статического метода getText(), который результатом возвращает текстовое значение. Одна версия метода подразумевает, что аргументом передается символьный массив, а результатом метод возвращает текстовую строку, сформированную из символов массива. Здесь мы фактически продублировали конструктор класса String, позволяющий создавать текстовые объекты на основе символьных массивов. Еще одна версия метода getText() подразумевает, что аргументами методу передаются два символьных значения (предполагается, что код первого символа-аргумента не больше кода второго символа-аргумента, хотя это и не принципиально). Как работают эти методы? Идея достаточно простая. В теле метода (в обеих версиях) объявляется локальная текстовая переменная txt, начальное значение которой - пустая текстовая строка. Дальше все зависит от того, какой аргумент или аргументы переданы методу. Если методу передан символьный массив, то запускается конструкция цикла for, в котором последовательно перебираются элементы символьного массива-аргумента и каждый символ дописывается к текстовой строке (команда 

  txt += symbs[k];
в теле цикла for, где через symbs обозначен переданный аргументом методу символьный массив). По завершении цикла значение из переменной txt возвращается результатом метода. Если же аргументами методу getText() переданы два символьных значения, то алгоритм выполнения метода немного другой. Локальной символьной переменной s присваивается значение первого символьного аргумента а. После этого запускается цикл while, в котором проверяется условие 
  s <= b
(через b обозначен второй символьный аргумент). Поскольку s и b - символьные переменные, то при вычислении значения выражения 
  s <= b
они автоматически приводятся к целочисленному формату. В итоге сравниваются коды символов. Фактически конструкция цикла выполняется до тех пор, пока символ из переменной s в кодовой таблице (или алфавите, если речь идет о буквах) находится до символа из аргумента b. За каждую итерацию цикла командой 
  txt += s;
к текстовой строке дописывается очередной символ, а затем командой 
  s++;
значение переменной s "увеличивается на единицу" - получаем следующий символ в кодовой таблице (следующую букву в алфавите). После того как текстовая строка сформирована, она возвращается результатом метода.

Если аргументом методу getText() передать два символа, причем код первого символа будет больше кода второго символа (то есть буквы-аргументы указаны не в алфавитном порядке), то результатом метод возвращает пустую текстовую строку. Причина в том, что при первой проверке условия 
  s <= b
в условной конструкции оно окажется ложным, и команды в теле цикла выполняться не будут. В итоге переменная txt, возвращаемая как результат метода, будет ссылаться на свое начальное значение - на пустую текстовую строку.

    В главном методе программы командой 

  char[] symbs = { 'Я', 'з', 'ы', 'к', ' ', 'C', '#' };
создается и инициализируется символьный массив, который мы используем для создания текстовых объектов. Но сначала проверяется содержимое этого массива, для чего массив symbs передается аргументом методу WriteLine(). В этом случае содержимое символьного массива печатается в консольном окне как текст.

Метод WriteLine() определен так, что если ему аргументом передается имя символьного массива, то в консольное окно выводятся символы из массива. Например, если symbs - символьный массив, то в результате выполнения команды 
  Console.WriteLine(symbs);
отображается содержимое массива symbs. Но если мы воспользуемся командой 
  Console.WriteLine (" " + symbs);
(аргументом методу передается сумма текстового литерала и имени символьного массива) или командой 
  Console.WriteLine ("{0}", symbs);   ,
то в консольном окне появится не содержимое массива symbs, а сообщение 
  System.Char[].
Дело в том, что в первом случае (команда 
  Console.WriteLine(symbs);
) вызывается версия метода WriteLine() для обработки символьного массива, переданного аргументом. А при выполнении команд 
  Console.WriteLine (" " + symbs);
и 
  Console .WriteLine ("{0}", symbs);
выполняется попытка преобразовать значение переменной symbs к текстовому формату. В этом случае вызывается метод ToString() (мы обсудим его чуть позже). Метод возвращает текстовое представление для преобразуемого объекта (в данном случае это symbs). По умолчанию метод возвращает идентификатор с названием класса для объекта. Для символьного массива это идентификатор System.Char[].

    Первый текстовый объект создается командой 

  String A = new String(symbs);
на основе символьного массива. Содержимое текстового объекта проверяем командой 
  Console.WriteLine("А: \"{0}\"", A);    .

Командой 
  Console.WriteLine("А: \"{0}\"", A);
отображается текстовая строка 
  "А: \"{0}\"",
в которой вместо блока {0} подставляется значение текстовой переменной А (точнее, подставляется текст из объекта, на который эта переменная ссылается). Причем отображаемый текст заключается в двойные кавычки. Двойные кавычки в текстовую строку добавляем с помощью инструкции \". Аналогичным способом проверяются значения прочих текстовых объектов.

    В данном случае текст получается объединением в одну строку символов из массива. Еще один объект создается командой 

  String B = new String(symbs, 1, 5);   .

    Теперь текстовый объект создается на основе того же массива symbs, но используются не все символы массива, а только символы, начиная со второго (с индексом 1 - второй аргумент), и используется 5 символов (третий аргумент).

    Текстовый объект, который создается командой 

  String C = new String('ы', 7);   ,
содержит текст из семи букв 'ы'.

    В результате выполнения команды 

  A = getText('A', 'H');
создается текстовый объект, который состоит из символов от 'А' до 'Н' включительно, а ссылка на этот объект записывается в переменную А.

    При выполнении команды 

  B = getText('H', 'A');
в переменную В записывается ссылка на текстовый объект с пустой текстовой строкой, поскольку в данном случае аргументы метода getText() указаны не в алфавитном порядке.

    Наконец, с помощью команды 

  C = getText(symbs);
на основе массива symbs создается текстовый объект, а ссылка на него присваивается значением переменной С.

    На следующем шаге мы рассмотрим операции с текстовыми объектами.




Предыдущий шаг Содержание Следующий шаг