Ввод/вывод

Наследниками класса Stream являются, в частности, три класса байтовых потоков:

Манипуляции с потоками предполагают НАПРАВЛЕННОСТЬ производимых действий. Информацию из потока можно ПРОЧИТАТЬ, а можно ее в поток ЗАПИСАТЬ. Как чтение, так и запись предполагают реализацию определенных механизмов байтового обмена с устройствами ввода/вывода.

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

Эти классы являются абстрактными. Это означает, что они не "привязаны" ни к какому конкретному потоку. Они лишь определяют интерфейс (набор методов), который позволяет организовать чтение и запись информации для любого потока.

В частности, в этих классах определены следующие методы, определяющие базовые механизмы символьного ввода/вывода. Для класса TextReader:

Для класса TextWriter, в свою очередь, определяется:

Эти классы являются базовыми для классов:

Вышеуказанные классы включают методы своих "предков" и позволяют осуществлять процессы чтения-записи непосредственно из конкретных байтовых потоков. Работа по организации ввода/вывода с использованием этих классов предполагает определение соответствующих объектов, "ответственных" за реализацию операций ввода/вывода, с явным указанием потоков, которые предполагается при этом использовать.

Еще одна пара классов потоков обеспечивает механизмы символьного ввода– вывода для строк:

В этом случае источником и хранилищем множества символов является символьная строка.

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

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

Предопределенные потоки ввода/вывода используются для реализации ввода/вывода в рамках консольных приложений. Это еще одна категория потоков.

В классах предопределенных потоков, в отличие от ранее рассмотренных потоков, явным образом задаются источник (откуда) и место размещения (куда) информации.

Основные свойства и методы этих потоков определены в классе System.Console. Класс Console является достаточно сложной конструкцией.

В рамках этого класса определены свойства, обеспечивающие доступ к предопределенным потокам. В классе System.Console таких потоков три ( In, Out, Error ).

Ниже описываются свойства этих потоков:

В классе System.Console также определены следующие СТАТИЧЕСКИЕ (!) функции – члены (вернее, множества СТАТИЧЕСКИХ ПЕРЕГРУЖЕННЫХ функций), обеспечивающие процедуры ввода/вывода:

При этом функции-члены класса Console ПО УМОЛЧАНИЮ обеспечивают связь с конкретным потоком. Например, при вызове метода

Console.WriteLine(...); // Список параметров опущен

информация направляется в поток, который представляется определенным в классе статическим свойством Console.Out. Это свойство предоставляет доступ к объекту – представителю класса TextWriter. Таким образом, класс Console также обеспечивает вызов соответствующей функции-члена от имени объекта – представителя класса TextWriter. Непосредственное обращение к члену класса Console (то есть к потоку), отвечающего за текстовый вывод, имеет следующую форму вызова:

Console.Out.WriteLine(...);

Вызов определенного в классе Console метода ReadLine

Console.ReadLine(...);

обеспечивает получение информации через поток, доступ к которому предоставляется статическим свойством Console.In. Непосредственный вызов аналогичной функции от имени члена класса TextReader выглядит следующим образом:

Console.In.ReadLine(...);

Функция – представитель класса Console, отвечающая за непосредственное направление информации в поток вывода сообщений об ошибках, не предусмотрена.

Вывод информации об ошибках может быть реализован путем непосредственного обращения к standard error output stream:

Console.Error.WriteLine(...);

Если вспомнить, что свойство Error возвращает ссылку на объект – представитель класса TextWriter и, так же как и свойство Out, обеспечивает вывод в окно консольного приложения, разделение сообщений, связанных с нормальным ходом выполнения приложения и сообщений об ошибках, становится более чем странным.

Информация, выводимая приложением в "штатном" режиме, и сообщения об ошибках одинаково направляются в окно приложения на экран консоли. Однако в классе Console реализована возможность перенаправления соответствующих потоков. Например, стандартный поток вывода можно перенаправить в файл, а поток сообщений об ошибках оставить без изменений — направленным в окно приложения. Результат перенаправления очевиден.

Процедуры перенаправления потоков осуществляются с помощью методов void SetIn(TextReader in), void SetOut(TextWriter out), void SetErr(TextWriter err) и будут рассмотрены ниже.

Функция ToString()

C# является языком, строго и в полном объеме реализующим принципы ООП. В этом языке все построено на классах и нет ничего, что бы не соответствовало принципам объектно-ориентированного программирования. Любой элементарный тип является наследником общего класса Object, реализующего, в частности, метод String ToString(), формирующий в виде human-readable текстовой строки описание тех или иных характеристик типа и значений объектов – представителей данного типа. Любой тип – наследник класса Object (а это ВСЕ типы!) имеет либо унаследованную, либо собственную переопределенную версию метода ToString(). Применительно к объектам предопределенного типа из CTS, соответствующие версии методов ToString() обеспечивают преобразование значения данного типа к строковому виду.

Все сделано для программиста. Реализация метода преобразования значения в строку в конечном счете оказывается скрытой от программиста. Именно поэтому вывод значений предопределенных типов с использованием функций Write и WriteLine в программах на языке C# осуществляется так легко и просто. В справочнике по поводу этих функций так и сказано:

The text representation of value is produced by calling Type.ToString.

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

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

Форматирование используется для преобразования значений "обычных" .NET Framework типов данных в строковое представление, да еще в соответствии с каким-либо общепринятым форматом. Например, целочисленное значение 100 можно представить в общепринятом формате currency для отображения валюты. Для этого можно использовать метод ToString() с использованием символа (строки?) форматирования (" C "). В результате может быть получена строка вида " $100.00 ". И это при условии, что установки операционной системы компьютера, на котором производится выполнение данного программного кода, соответствуют U.S. English specified as the current culture (имеется в виду "Настройка языковых параметров, представление чисел, денежных единиц, времени и дат").

int MyInt = 100;
 String MyString = MyInt.ToString("C");
 Console.WriteLine(MyString);

Консольный ввод/вывод. Функции – члены класса Console

При обсуждении процедур ввода/вывода следует иметь в виду одно важное обстоятельство. Независимо от типа выводимого значения, в конечном результате выводится СИМВОЛЬНОЕ ПРЕДСТАВЛЕНИЕ значения. Это становится очевидным при выводе информации в окно приложения, что и обеспечивают по умолчанию методы Console.Write и Console.WriteLine.

WriteLine отличается тем, что завершает свою работу обязательным выводом Escape-последовательности line feed/carriage return.

Console.WriteLine("The Captain is on the board!"); // Вывод строки.
Console.WriteLine(314); //Символьное представление целочисленного значения.
Console.WriteLine(3.14); //Символьное представление значения типа float.

Выводимая символьная строка может содержать Escape-последовательности, которые при выводе информации в окно представления позволяют создавать различные "специальные эффекты".

Методы с одним параметром достаточно просты. Практически все происходит само собой. Уже на стадии компиляции при выяснении типа выводимого значения подбирается соответствующий вариант перегруженной функции вывода.

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

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

Эти методы называются ПЕРЕГРУЖАЕМЫМИ (см. о перегрузке методов). Для программиста C# это означает возможность вызова этих функций с различными параметрами. Можно предположить, что различным вариантам списков параметров функции могут соответствовать различные варианты функций вывода.

Ниже представлен вариант метода WriteLine с тремя параметрами. Во всех случаях, когда количество параметров превышает 1, первый параметр обязан быть символьной строкой:

Console.WriteLine("qwerty",314,3.14);

Чтобы понять, как выполняется такой оператор, следует иметь в виду, что всякий параметр метода является выражением определенного типа, которое в процессе выполнения метода может вычисляться для определения значения соответствующего выражения. Таким образом, при выполнении метода WriteLine должны быть определены значения его параметров, после чего в окне приложения должна появиться определенная последовательность символов. Ниже представлен результат выполнения выражения вызова функции:

qwerty

Значения второго и третьего параметров не выводятся.

Дело в том, что первый строковый параметр выражений вызова функций Write и WriteLine используется как управляющий шаблон для представления выводимой информации. Значения следующих за строковым параметром выражений будут выводиться в окно представления лишь в том случае, если первый параметр-строка будет явно указывать места расположения выводимых значений, соответствующих этим параметрам. Явное указание обеспечивается маркерами выводимых значений, которые в самом простом случае представляют собой заключенные в фигурные скобки целочисленные литералы (например, {3}).

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

Таким образом, оператор

Console.WriteLine("The sum of {0} and {1} is {2}",314,3.14,314+3.14);

обеспечивает вывод следующей строки:

The sum of 314 and 3.14 is 317.14

В последнем операнде выражения вызова WriteLine при вычислении значения выражения используется неявное приведение типа. При вычислении значения суммы операнд типа int без потери значения приводится к типу float. Безопасные преобразования типов проводятся автоматически.

Несмотря на явную абсурдность выводимых утверждений, операторы

Console.WriteLine("The sum of {0} and {1} is {0}",314,3.14,314+3.14);
Console.WriteLine("The sum of {2} and {1} is {0}",314,3.14,314+3.14);

также отработают вполне корректно.

Консольный вывод. Форматирование

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

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

Console.WriteLine("***{0,10}***",3.14);

будет следующая строка:

***3.14 ***

А выполнение такого оператора:

Console.WriteLine("***{0,–10}***",3.14);

приведет к следующему результату:

*** 3.14***

Кроме того, в маркерах вывода могут также размещаться дополнительные строки форматирования ( FormatString ). При этом маркер приобретает достаточно сложную структуру, внешний вид которой в общем случае можно представить следующим образом ( M – значение индекса, N – область позиционирования):

{M,N:FormatString},

либо

{M:FormatString},

если не указывается значение области позиционирования.

Сама же строка форматирования аналогична ранее рассмотренной строке – параметру метода ToString и является комбинацией предопределенных символов форматирования и дополнительных целочисленных значений.

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

Следующие примеры иллюстрируют варианты применения маркеров со строками форматирования:

Console.WriteLine("Integer fotmating – {0:D3},{1:D5}",12345, 12);
Console.WriteLine("Currency formatting – {0:C},{1:C5}", 99.9, 999.9);
Console.WriteLine("Exponential formatting – {0:E}", 1234.5);
Console.WriteLine("Fixed Point formatting – {0:F3}", 1234.56789);
Console.WriteLine("General formatting – {0:G}", 1234.56789);
Console.WriteLine("Number formatting – {0:N}", 1234567.89);
Console.WriteLine("Hexadecimal formatting – {0:X7}",12345);//Integers only!

В результате выполнения этих операторов в окно консольного приложения будут выведены следующие строки:

Integer fotmating – 12345,00012
Currency formatting – $99.90,$999.90000
Exponential formatting – 1.234500E+003
Fixed Point formatting – 1234.568
General formatting – 1234.56789
Number formatting – 1,234,567.89
Hexadecimal formatting – 0003039

Нестандартное (custom) форматирование значений

В маркерах выражений вызова функций вывода могут также размещаться спецификаторы (custom format strings), реализующие возможности расширенного форматирования.

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

Следует иметь в виду, что на выходные строки, создаваемые с помощью некоторых из этих знаков, влияют настройки компонента "Язык и региональные стандарты" панели управления объекта NumberFormatInfo, связанного с текущим потоком. Результаты будут различными на компьютерах с разными параметрами культуры.

E0
 E+0
 E–0
 e0
 e+0
 e–0

Строки формата с фиксированной запятой (не содержащие подстрок " E0 ", " E+0 ", " E–0 ", " e0 ", " e+0 " или " e–0 ") ОКРУГЛЯЮТ значение с точностью, заданной количеством знаков-заместителей справа от разделителя целой и дробной частей.

Если в строке формата нет разделителя (точки), число округляется до ближайшего целого значения.

Если в целой части числа больше цифр, чем знаков – заместителей цифр, лишние знаки копируются в выходную строку перед первым знаком – заместителем цифры.

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

При генерации выходной строки в этом типе форматирования не учитывается предыдущее форматирование. Например, при использовании разделителей секций отрицательные значения всегда отображаются без знака "минус". Чтобы конечное форматированное значение содержало знак "минус", его следует явным образом включить в настраиваемый указатель формата. В примере ниже показано применение разделителей секций для форматирования.

Следующий код демонстрирует использование разделителей секций при форматировании строки:

// Объявляются переменные с различными значениями (положительное, 
 // отрицательное, нулевое)
 double MyPos = 19.95, MyNeg = –19.95, MyZero = 0.0;
 string MyString = MyPos.ToString("$#,##0.00;($#,##0.00);Zero");
 // In the U.S. English culture, MyString has the value: $19.95.
 MyString = MyNeg.ToString("$#,##0.00;($#,##0.00);Zero");
 // In the U.S. English culture, MyString has the value: ($19.95).
 MyString = MyZero.ToString("$#,##0.00;($#,##0.00);Zero");
 // In the U.S. English culture, MyString has the value: Zero.

Приведенная далее таблица иллюстрирует варианты представления выводимых значений в зависимости от используемых строк форматирования. Предполагается, что форматирование проводится в рамках ToString метода, а значения в столбце "Формат" соответствуют используемой строке форматирования.

В столбце "Data type" указывается тип форматируемого значения. В столбце "Значение" – значение, подлежащее форматированию. В столбце "Вывод" отображается результат форматирования строки для U.S. English параметров культуры.

Демонстрация custom number formatting. Еще один пример:

Double myDouble = 1234567890;
 String myString = myDouble.ToString( "(# ##) ### – ####" );
 // The value of myString is "(123) 456 – 7890".
 int MyInt = 42;
 MyString = MyInt.ToString( "My Number \n= #" );
 // In the U.S. English culture, MyString has the value:
 // "My Number
 // = 42".

Консольный ввод. Преобразование значений

Следует иметь в виду, что чтение информации из входного потока класса Console связано с получением из буфера клавиатуры СИМВОЛЬНЫХ последовательностей и в большинстве случаев предполагает дальнейшие преобразования этих последовательностей к соответствующему типу значений.

Консольный ввод предполагает использование уже известных статических (!) функций – членов класса Console:

public static int Read();

public static string ReadLine();

Строка определяется как последовательность символов, завершаемая парой escape-символов carriage return line feed (" \r\n ") – ( hexadecimal 0x000d ), ( hexadecimal 0x000a ). При этом возвращаемая строка эти символы не включает.

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

В .NET FCL реализован процесс преобразования информации в рамках Общей Системы Типов (CTS).

.NET Framework Class Library включает класс System.Convert, в котором реализовано множество функций-членов, предназначенных для выполнения ЗАДАЧИ ПРЕОБРАЗОВАНИЯ ЗНАЧЕНИЙ ОДНОГО базового ТИПА В ЗНАЧЕНИЯ ДРУГОГО базового ТИПА. В частности, в этом классе содержится множество функций (по нескольку функций на каждый базовый тип), обеспечивающих попытку преобразования символьных строк в значения базовых типов.

Кроме того, множество классов, входящих в CTS и FCL, располагают вариантами функции Parse(), основное назначение которой – ПОПЫТКА преобразования строк символов (в частности, получаемых в результате выполнения методов консольного ввода) в значения соответствующих типов.

При обсуждении функций преобразования неслучайно употребляется слово "попытка". Не каждая строка символов может быть преобразована к определенному базовому типу. Для успешного преобразования предполагается, что символьная строка содержит символьное представление значения в некотором общепринятом формате в соответствии с соответствующей существующей в операционной системе настройкой языковых параметров, представления чисел, времени и дат. С аналогичной ситуацией мы уже сталкивались при обсуждении понятия литералов. В случае успешного преобразования функции возвращают результат преобразования в виде значения соответствующего типа.

Если же значение одного типа не может быть преобразовано к значению другого типа, преобразующая функция ВЫРАБАТЫВАЕТ ИСКЛЮЧЕНИЕ, с помощью которого CLR (то есть среда выполнения!) уведомляется о неудачной попытке преобразования.

Файловый ввод/вывод

FileMode enumeration:

описывает, каким образом операционная система должна открывать файл.

FileAccess enumerations:

using System;
 using System.IO;

namespace fstream00
 {
 class Class1
 {
 static	string[] str = {
 "1234567890",
 "qwertyuiop",
 "asdfghjkl",
 "zxcvbnm", 	};

static void Main(string[] args)
 {
 int i;
 // Полное имя файла.
 string filename = @"D:\Users\WORK\Cs\fstream00\test.txt";
 string xLine = "";
 char[] buff = new char[128];
 for (i = 0; i < 128; i++) buff[i] = (char)25;
 // Запись в файл.
 FileStream fstr = new FileStream(filename,
 FileMode.Create,
 FileAccess.Write);
 BufferedStream buffStream = new BufferedStream(fstr);
 StreamWriter streamWr = new StreamWriter(buffStream);
 for (i = 0; i < str.Length; i++)
  {
 streamWr.WriteLine(str[i]);	
 }

streamWr.Flush();
 streamWr.Close();

Console.WriteLine("–––––––––––––––––––––––––––––––––––––––––––");

fstr = new FileStream(filename,
 FileMode.Open,
 FileAccess.Read);

StreamReader streamRd = new StreamReader(fstr);
 for ( ; xLine != null; )
 {
 xLine = streamRd.ReadLine();
 Console.WriteLine(xLine);	
 }


Console.WriteLine("––––––––––––––––––––––––––––––––––––––––––––");
 fstr.Seek(0, SeekOrigin.Begin);
 streamRd.Read(buff,0,10);
 Console.WriteLine(new string(buff));
 Console.WriteLine("1––––––––––––––––––––––––––––––––––––––––––");

streamRd.Read(buff,0,20);
 Console.WriteLine(new string(buff));
 Console.WriteLine("2––––––––––––––––––––––––––––––––––––––––––");
Console.WriteLine(streamRd.Read(buff,0,15));
 i = (int)fstr.Seek(–20, SeekOrigin.Current);
 Console.WriteLine(streamRd.ReadLine());

Console.WriteLine("3––––––––––––––––––––––––––––––––––––––––––");
 }
 }
 }

Пример перенаправления потоков. В файл можно записать информацию, используя привычные классы и методы!

using System;
 using System.Collections.Generic;
 using System.Text;
 using System.IO;

namespace OutFile
 {
 class Program
 {

static void Main(string[] args)
 {
 string buff;

FileStream outFstr, inFstr; // Ссылки на файловые потоки.

 // Ссылка на выходной поток. Свойства и методы,
 // которые обеспечивают запись в...
 StreamWriter swr;

 // Ссылка на входной поток. Свойства и методы,
 // которые обеспечивают чтение из...
 StreamReader sr;  

 // Класс Console –  средство управления ПРЕДОПРЕДЕЛЕННЫМ потоком. 
 // Сохранили стандартный выходной поток,
 // связанный с окошком консольного приложения. 
TextWriter twrConsole = Console.Out;

 // Сохранили стандартный входной поток, связанный с буфером клавиатуры.
 TextReader trConsole = Console.In;

inFstr = new FileStream
               (@"F:\Users\Work\readme.txt", FileMode.Open, FileAccess.Read);
 sr = new StreamReader(inFstr); // Входной поток, связанный с файлом. 

outFstr = new FileStream
               (@"F:\Users\Work\txt.txt", FileMode.Create, FileAccess.Write);
 swr = new StreamWriter(outFstr); // Выходной поток, связанный с файлом.
 // А вот мы перенастроили предопределенный входной поток.
 // Он теперь связан не с буфером клавиатуры, а с файлом, открытым для чтения.
 Console.SetIn(sr);
 Console.SetOut(swr);
     
while (true)
 {
 // Но поинтересоваться в предопределенном потоке отностительно
 // конца файла невозможно.
 // Такого для предопределенных потоков просто не предусмотрено. 
if (sr.EndOfStream) break;

 // А вот читать - можно.
 buff = Console.ReadLine();
 Console.WriteLine(buff);           
    
 }
Console.SetOut(twrConsole);
 Console.WriteLine("12345");            
Console.SetOut(swr);
 Console.WriteLine("12345");
 Console.SetOut(twrConsole);
 Console.WriteLine("67890");
 Console.SetOut(swr);
 Console.WriteLine("67890");

sr.Close();
 inFstr.Close();
 swr.Close();
 outFstr.Close();
 }
 }
 }