/ Language: Русский / Genre:antique

C# 4.0 полное руководство - 2011

Герберт Шилдт


antiqueГербертШилдтC/storebooks/G/G-Shildt/Cn-40-Polnoe-Rukovodstvo-2011/ 4.0 полное руководство - 2011ruГербертШилдтcalibre 0.8.5127.5.201223c93f74-7eb6-429d-8f6c-5d7ab8c591201.0

ПОЛНОЕ

РУКОВОДСТВО

Su P# A n

Reference    В

HERBERT SCHILDT

ПОЛНОЕ РУКОВОДСТВО

С#4.0

ГЕРБЕРТ ШИЛДТ

Москва • Санкт-Петербург • Киев 2011

ББК 32.973.26-018.2.75 Ш 57 УДК 681.3.07

Издательский дом "Вильямс"

Зав. редакцией С.Н. Тригуб Перевод с английского и редакция И.В. Берштейна

По общим вопросам обращайтесь в Издательский дом "Вильямс" по адресу: info@williamspublishing.com, http://www.williamspublishing.com

Шилдт, Герберт.

Ш57 C# 4.0: полное руководство. : Пер. с англ. — М. : ООО "И.Д. Вильямс", 2011. — 1056 с.: ил. — Парал. тит. англ.

ISBN 978-5-8459-1684-6 (рус.)

ББК 32.973.26-018.2.75

Все названия программных продуктов являются зарегистрированными торговыми марками соответствующих фирм.

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

Authorized translation from the English language edition published by McGraw-Hill Companies, Copyright © 2010

All rights reserved. Except as permitted under the Copyright Act of 1976, no part of this publication may be reproduced or distributed in any form or by any means, or stored in a database or retrieval system, without the prior written permission of publisher, with the exception that the program listings may be entered, stored, and executed in a computer system, but they may not be reproduced for publication.

Russian language edition published by Williams Publishing House according to the Agreement with R&I Enterprises International, Copyright © 2011

Научно-популярное издание Герберт Шилдт C# 4.0: полное руководство

Литературный редактор Е.П. Перестюк

Верстка А.В. Чернокозинская Художественный редактор С А. Чернокозинский Корректор АЛ. Гордиенко

Подписано в печать 17.09.2010. Формат 70x100/16. Гарнитура Times. Печать офсетная.

Уел. печ. л. 85,14. Уч.-изд. л. 51,55.

Тираж 1500 экз. Заказ № 24007.

Отпечатано по технологии CtP в ОАО "Печатный двор" им. А. М. Горького 197110, Санкт-Петербург, Чкаловский пр., 15.

ООО "И. Д. Вильямс", 127055, г. Москва, ул. Лесная, д. 43, стр. 1

© Издательский дом "Вильямс", 2011 © by The McGraw-Hill Companies, 2010

ISBN 978-5-8459-1684-6 (рус.) ISBN 0-07-174116-Х (англ.)

Оглавление

Содержание

Краткий обзор элементов C#

Точка с запятой и оформление исходного текста программы

Управляющие последовательности символов

Операторы

Поразрядные составные операторы присваивания

Объявление управляющих переменных в цикле for

Добавление метода в класс Building

Массивы и строки

Строки

Подробнее о методах и классах

Возврат объектов из методов

Необязательные аргументы и неоднозначность

Перегрузка операторов

Операторы преобразования

Индексаторы и свойства

Применение индексаторов и свойств

Наследование

Порядок вызова конструкторов

Упаковка и распаковка

Интерфейсы, структуры и перечисления

Инициализация перечисления

Обработка исключительных ситуаций

Получение производных классов исключений

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

Использование класса FileStream для копирования файла

Применение классов StringReader и StringWriter

Делегаты, события и лямбда-выражения

События

Пространства имен, препроцессор и сборки

Директива #еггог

Получение типов данных из сборок

Обобщения

// ...

Сравнение экземпляров параметра типа

// ...

Применение вложенных операторов from

Формирование запросов с помощью методов запроса

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

Частичные методы

Библиотека C#

Структуры типов данных с плавающей точкой

Окончание табл. 21.9

Сортировка и поиск в массивах

Класс Tuple

Сцепление строк ,

Заполнение и обрезка строк

Определение пользовательского формата даты и времени

Свойство IsBackground

Семафор

Многопоточное программирование. Часть вторая: библиотека TPL

Другие средства организации задач

Вопросы эффективности PLINQ

Сортировка и поиск в коллекции типа ArrayList

Специальные коллекции

Класс DictionaryCTKey, TValue>

Сохранение объектов, определяемых пользователем классов, в коллекции

Создание именованного итератора

Исключения, генерируемые методом GetResponseStream ()

Дескрипторы XML-комментариев

п

Оглавление

Содержание

Глава 20. Небезопасный код, указатели, обнуляемые типы и разные ключевые слова 681

06 авторе

Герберт Шилдт (Herbert Schildt) является одним из самых известных специалистов по языкам программирования С#, C++, С и Java. Его книги по программированию изданы миллионными тиражами и переведены с английского на все основные иностранные языки. Его перу принадлежит целый ряд популярных книг, в том числе Полный справочник по Java, Полный справочник по C++, Полный справочник по С (все перечисленные книги вышли в издательстве "Вильямс" в 2007 и 2008 гг.). Несмотря на то что Герберт Шилдт интересуется всеми аспектами вычислительной техники, его основная специализация — языки программирования, в том числе компиляторы, интерпретаторы и языки программирования роботов. Он также проявляет живой интерес к стандартизации языков. Шилдт окончил Иллинойский университет и имеет степени магистра и бакалавра. Связаться с ним можно, посетив его веб-сайт по адресу www.HerbSchildt.com.

N

0 научном редакторе

Майкл ХоварД (Michael Howard) работает руководителем проекта программной защиты в группе техники информационной безопасности, входящей в подразделение разработки защищенных информационных систем (TwC) корпорации Microsoft, где он отвечает за внедрение надежных с точки зрения безопасности методов проектирования, программирования и тестирования информационных систем в масштабах всей корпорации. Ховард является автором методики безопасной разработки (Security Development Lifecycle — SDL) — процесса повышения безопасности программного обеспечения, выпускаемого корпорацией Microsoft.

Свою карьеру в корпорации Microsoft Ховард начал в 1992 году, проработав два первых года с ОС Windows и компиляторами в службе поддержки программных продуктов (Product Support Services) новозеландского отделения корпорации, а затем перейдя в консультационную службу (Microsoft Consulting Services), где он занимался клиентской поддержкой инфраструктуры безопасности и помогал в разработке заказных проектных решений и программного обеспечения. В 1997 году Ховард переехал в Соединенные Штаты и поступил на работу в отделение Windows веб-службы Internet Information Services, представлявшей собой веб-сервер следующего поколения в корпорации Microsoft, прежде чем перейти в 2000 году к своим текущим служебным обязанностям.

Ховард является редактором журнала IEEE Security & Privacy, часто выступает на конференциях, посвященных безопасности программных средств, и регулярно пишет статьи по вопросам безопасного программирования и проектирования программного обеспечения. Он является одним из авторов шести книг по безопасности информационных систем.

Благодарности

Особая благодарность выражается Майклу Ховарду за превосходное научное редактирование книги. Его знания, опыт, дельные советы и предложения оказались неоценимыми.

Предисловие

эффективности и переносимости разрабатываемых ими программ. Они не менее требовательны к применяемым инструментальным средствам и особенно к языкам программирования. Существует немало языков программирования, но лишь немногие из них действительно хороши. Хороший язык программирования должен быть одновременно эффективным и гибким, а его синтаксис — кратким, но ясным. Он должен облегчать создание правильного кода, не мешая делать это, а также поддерживать самые современные возможности программирования, но не ультрамодные тенденции, заводящие в тупик. И наконец, хороший язык программирования должен обладать еще одним, едва уловимым качеством: вызывать у нас такое ощущение, будто мы находимся в своей стихии, когда пользуемся им. Именно таким языком и является С#.

рограммисты — люди требовательные, постоянно

ищущие пути повышения производительности,

Язык C# был создан корпорацией Microsoft для поддержки среды .NET Framework и опирается на богатое наследие в области программирования. Его главным разработчиком был Андерс Хейльсберг (Anders Hejlsberg) — известнейший специалист по программированию. C# происходит напрямую от двух самых удачных в области программирования языков: С и C++. От языка С он унаследовал синтаксис, многие ключевые слова и операторы, а от C++ — усовершенствованную объектную модель. Кроме того, C# тесно связан с Java — другим не менее удачным языком.

Имея общее происхождение, но во многом отличаясь, C# и Java похожи друг на друга как близкие, но не кровные родственники. В обоих языках поддерживается

распределенное программирование и применяется промежуточный код для обеспечения безопасности и переносимости, но отличия кроются в деталях реализации. Кроме того, в обоих языках предоставляется немало возможностей для проверки ошибок при выполнении, обеспечения безопасности и управляемого исполнения, хотя и в этом случае отличия кроются в деталях реализации. Но в отличие от Java, язык C# предоставляет доступ к указателям — средствам программирования, которые поддерживаются в C++. Следовательно, C# сочетает в себе эффективность, присущую C++, и типовую безопасность, характерную для Java. Более того, компромиссы между эффективностью и безопасностью в этом языке программирования тщательно уравновешены и совершенно прозрачны.

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

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

А теперь рассмотрим второе существенное исправление, внесенное в версии C# 3.0 . Не будет преувеличением сказать, что в этой версии введены свойства, переопределившие саму суть C# и поднявшие на новый уровень разработку языков программирования. Среди многих новых свойств особенно выделяются два следующих: LINQ и лябмда-выражения. Сокращение LINQ означает язык интегрированных запросов. Это языковое средство позволяет создавать запросы к базе данных, используя элементы С#. А лябмда-выражения — это синтаксис функционалов с помощью лямбда-оператора =>, причем лябмда-выражения часто применяются в LINQ-выражениях.

И наконец, третье существенное исправление было внесено в версии C# 4.0, описываемой в этой книге. Эта версия опирается на предыдущие и в то же время предоставляет целый ряд новых средств для рационального решения типичных задач программирования. В частности, в ней внедрены именованные и необязательные аргументы, что делает более удобным вызов некоторых видов методов; добавлено ключевое слово dynamic, упрощающее применение C# в тех случаях, когда тип данных создается во время выполнения, например, при сопряжении с моделью компонентных объектов (СОМ) или при использовании рефлексии; а средства ковариантности и контравариантности, уже поддерживавшиеся в С#, были расширены с тем, чтобы использовать параметры типа. Благодаря усовершенствованиям среды .NET Framework, представленной в виде библиотеки С#, в данной версии поддерживается параллельное программирование средствами TPL (Task Parallel Library — Библиотека распараллеливания задач) и PLINQ (Parallel LINQ — Параллельный язык интегрированных запросов). Эти подсистемы упрощают создание кода, который мае-

Предисловие 27

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

Благодаря своей способности быстро приспосабливаться к постоянно меняющимся потребностям в области программирования C# по-прежнему остается живым и новаторским языком. А следовательно, он представляет собой один из самых эффективных и богатых своими возможностями языков в современном программировании. Это язык, пренебречь которым не может позволить себе ни один программист. И эта книга призвана помочь вам овладеть им.

Структура книги

В этой книге описывается версия 4.0 языка С#. Она разделена на две части. В части I дается подробное пояснение языка С#, в том числе новых средств, внедренных в версии 4.0. Это самая большая часть книги, в которой описываются ключевые слова, синтаксис и средства данного языка, а также операции ввода-вывода и обработки файлов, рефлексия и препроцессор.

В части II рассматриваемся библиотека классов С#, которая одновременно является библиотекой классов для среды .NET Framework. Эта библиотека довольно обширна, но за недостатком места в этой книге просто невозможно описать ее полностью. Поэтому в части II основное внимание уделяется корневой библиотеке, которая находится в пространстве имен System. Кроме того, в этой части рассматриваются коллекции, организация многопоточной обработки, сетевого подключения к Интернету, а также средства TPL и PLINQ. Это те части более обширной библиотеки классов, которыми пользуется всякий, программирующий на языке С#.

Книга для всех программирующих

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

Необходимое программное обеспечение

Для компилирования и выполнения примеров программ на C# 4.0, приведенных в этой книге, вам потребуется пакет Visual Studio 2010 (или более поздняя версия).

Код, доступный в Интернете

Не забывайте о том, что исходный код для примеров всех программ, приведенных в этой книге, свободно доступен для загрузки по адресу www .mhprofessional. com.

Что еще почитать

Эта книга — своеобразный "ключ" к целой серии книг по программированию, написанных Гербертом Шилдтом. Ниже перечислены другие книги, которые могут представлять для вас интерес.

Для изучения языка программирования Java рекомендуются следующие книги.

Полный справочник по Java (ИД " Вильямс", 2007 г.)

]ava: руководство для начинающих (ИД " Вильямс", 2008 г.)

SWING: руководство для начинающих (ИД "Вильямс", 2007 г.)

Искусство программирования на Java (ИД "Вильямс", 2005 г.)

Java. Методики программирования Шилдта (ИД "Вильямс", 2008 г.)

Для изучения языка программирования C++ особенно полезными окажутся следующие книги.

Полный справочник по C++ (ИД "Вильямс", 2007 г.)

C++. Руководство для начинающих (ИД "Вильямс", 2005 г.)

STL Programming From the Ground Up

Искусство программирования на С++

С++. Методики программирования Шилдта (ИД "Вильямс", 2009 г.)

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

Полный справочник по С (ИД "Вильямс", 2007 г.)

От издательства

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

Мы ждем ваших комментариев и надеемся на них. Вы можете прислать нам бумажное или электронное письмо, либо просто посетить наш Web-сервер и оставить свои замечания там. Одним словом, любым удобным для вас способом дайте нам знать, нравится или нет вам эта книга, а также выскажите свое мнение о том, как сделать наши книги более интересными для вас.

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

E-mail:    info0williamspublishing. com

WWW:    http://www.williamspublishing.com

Информация для писем из:

России:    127055, г. Москва, ул. Лесная, д. 43, стр. 1

Украины:    03150, Киев, а/я 152

ЧАСТЬ 1 Язык C#

В части I рассматриваются отдельные элементы языка С#, в том числе ключевые слова, синтаксис и операторы. Описывается также ряд основополагающих методов программирования, тесно связанных с языком С#, включая организацию ввода-вывода и рефлексию.

ГЛАВА 1 Создание C#

ГЛАВА 2 Краткий обзор элементов C#

ГЛАВА 3 Типы данных, литералы и переменные ГЛАВА 4 Опера I оры ГЛАВА 5 Управляющие операторы

ГЛАВА 6 Введение в классы, объекты и методы ГЛАВА 7 Массивы и строки ГЛАВА 8 Подробнее о методах и классах ГЛАВА 9 Перегрузка операторов ГЛАВА 10 Индексаторы и свойства

ГЛАВА 11 Наследование ГЛАВА 12 Интерфейсы, структуры и перечисления ГЛАВА 13 Обработка исключительных ситуаций

ГЛАВА 14 Применение средств ввода-вывода ГЛАВА 15 Делегаты, события и лямбда-выражения ГЛАВА 16 Пространства имен, препроцессор и сборки

ГЛАВА 17 Динамическая идентификация типов, рефлексия и атрибуты ГЛАВА 18 Обобщения ГЛАВА 19 LINQ ГЛАВА 20 Небезопасный код, указатели, обнуляемые типы и разные ключевые слова

Глава 1 Создание C#

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

Назначение этой главы — представить C# в его историческом контексте, упомянув и те движущие силы, которые способствовали его созданию, выработке его конструктивных особенностей и определили его влияние на другие языки программирования. Кроме того, в этой главе поясняется взаимосвязь C# со средой .NET Framework. Как станет ясно из дальнейшего материала, C# и .NET Framework совместно образуют весьма изящную среду программирования.

Генеалогическое дерево C#

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

У языка программирования C# "богатое наследство". Он является прямым наследником двух самых удачных языков программирования: С и C++. Он также имеет тесные родственные связи с еще одним языком: Java. Ясное представление об этих взаимосвязях имеет решающее значение для понимания С#. Поэтому сначала определим, какое место занимает C# среди этих трех языков.

Язык С - начало современной эпохи программирования

Создание С знаменует собой начало современной эпохи программирования. Язык С был разработан Деннисом Ритчи (Dennis Ritchie) в 1970-е годы для программирования на мини-ЭВМ DEC PDP-11 под управлением операционной систему Unix. Несмотря на то что в ряде предшествовавших языков, в особенности Pascal, был достигнут значительный прогресс, именно С установил тот образец, которому до сих пор следуют в программировании.

Язык С появился в результате революции в структурном программировании в 1960-е годы. До появления структурного программирования писать большие программы было трудно, поскольку логика программы постепенно вырождалась в так называемый "макаронный" код — запутанный клубок безусловных переходов, вызовов и возвратов, которые трудно отследить. В структурированных языках программирования этот недостаток устранялся путем ввода строго определенных управляющих операторов, подпрограмм с локальными переменными и других усовершенствований. Благодаря применению методов структурного программирования сами программы стали более организованными, надежными и управляемыми.

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

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

Появление ООП и C++

К концу 1970-х годов масштабы многих проектов приблизились к пределам, с которыми уже не могли справиться методики структурного программирования вообще и язык С в частности. Для решения этой проблемы было открыто новое направление в программировании — так называемое объектно-ориентированное программирование (ООП). Применяя метод ООП, программист мог работать с более "крупными" программами. Но главная трудность заключалась в том, что С, самый распространенный в то время язык, не поддерживал ООП. Стремление к созданию объектно-ориентированного варианта С в конечном итоге привело к появлению C++.

Язык C++ был разработан в 1979 году Бьярне Страуструпом (Bjarne Stroustrup), ра-бртавшим в компании Bell Laboratories, базировавшейся в Мюррей-Хилл, шт. Нью-Джерси. Первоначально новый язык назывался "С с классами", но в 1983 году он был переименован в C++. Язык С полностью входит в состав C++, а следовательно, С служит основанием, на котором зиждется C++. Большая часть дополнений, введенных Страуструпом, обеспечивала плавный переход к ООП. И вместо того чтобы изучать совершенно новый язык, программирующему на С требовалось лишь освоить ряд новых свойств, чтобы воспользоваться преимуществами методики ООП.

В течение 1980-х годов C++ все еще оставался в тени, интенсивно развиваясь, но к началу 1990-х годов, когда он уже был готов для широкого применения, его популярность в области программирования заметно возросла. К концу 1990-х годов он стал наиболее широко распространенным языком программирования и в настоящее время по-прежнему обладает неоспоримыми преимуществами языка разработки высокопроизводительных программ системного уровня.

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

Появление Интернета и Java

Следующим важным шагом в развитии языков программирования стала разработка Java. Работа над языком Java, который первоначально назывался Oak (Дуб), началась в 1991 году в компании Sun Microsystems. Главной "движущей силой" в разработке Java был Джеймс Гослинг (James Gosling), но не малая роль в работе над этим языком принадлежит также Патрику Ноутону (Patrick Naughton), Крису Уорту (Chris Warth), Эду Фрэнку (Ed Frank) и Майку Шеридану (Mike Sheridan).

Java представляет собой структурированный, объектно-ориентированный язык с синтаксисом и конструктивными особенностями, унаследованными от C++. Нововведения в Java возникли не столько в результате прогресса в искусстве программирования, хотя некоторые успехи в данной области все же были, сколько вследствие перемен в вычислительной среде. До появления на широкой арене Интернета большинство программ писалось, компилировалось и предназначалось для конкретного процессора и операционной системы. Как известно, программисты всегда стремились повторно использовать свой код, но, несмотря на это, легкой переносимости программ из одной среды в другую уделялось меньше внимания, чем более насущным задачам. Тем не менее с появлением Интернета, когда в глобальную сеть связывались разнотипные процессоры и операционные системы, застаревшая проблема переносимости программ вновь возникла с неожиданной остротой. Для решения проблемы переносимости потребовался новый язык, и им стал Java.

Самым важным свойством (и причиной быстрого признания) Java является способность создавать межплатформенный, переносимый код, тем не менее, интересно отметить, что первоначальным толчком для разработки Java послужил не Интернет, а потребность в независящем от платформы языке, на котором можно было бы разрабатывать программы для встраиваемых контроллеров. В 1993 году стало очевидно, что вопросы межплатформенной переносимости, возникавшие при создании кода для встраиваемых контроллеров, стали актуальными и при попытке написать код для Интернета. Напомним, что Интернет — это глобальная распределенная вычислительная среда, в которой работают и мирно "сосуществуют" разнотипные компьютеры. И в итоге оказалось, что теми же самыми методами, которыми решалась проблема переносимости программ в мелких масштабах, можно решать аналогичную задачу в намного более крупных масштабах Интернета.

Переносимость программ на Java достигалась благодаря преобразованию исходного кода в промежуточный, называемый байт-кодом. Этот байт-код затем выполнялся виртуальной машиной Java (JVM) — основной частью исполняющей системы Java. Таким образом, программа на Java могла выполняться в любой среде, для которой была доступна JVM. А поскольку JVM реализуется относительно просто, то она сразу же стала доступной для большого числа сред.

Применением байт-кода Java коренным образом отличается от С и C++, где исходный код практически всегда компилируется в исполняемый машинный код, который, в свою очередь, привязан к конкретному процессору и операционной системе. Так, если требуется выполнить программу на С или C++ в другой системе, ее придется перекомпилировать в машинный код специально для данной вычислительной среды. Следовательно, для создания программы на С или C++, которая могла был выполняться в различных средах, потребовалось бы несколько разных исполняемых версий этой программы. Это оказалось бы не только непрактично, но и дорого. Изящным и рентабельным решением данной проблемы явилось применение в Java промежуточного кода. Именно это решение было в дальнейшем приспособлено для целей языка С#.

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

Создание C#

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

Другой возможностью, отсутствующей в Java, является полная интеграция с платформой Windows. Несмотря на то что программы на Java могут выполняться в среде Windows, при условии, что установлена виртуальная машина Java, среды Java и Windows не являются сильно связанными. А поскольку Windows является самой распространенной операционной системой во всем мире, то отсутствие прямой поддержки Windows является существенным недостатком Java.

Для удовлетворения этих и других потребностей программирования корпорация Microsoft разработала в конце 1990-х годов язык C# как часть общей стратегии .NET. Впервые он был выпущен в виде альфа-версии в середине 2000 года. Главным разработчиком C# был Андерс Хейльсберг — один из ведущих в мире специалистов по языкам программирования, который может похвалиться рядом заметных достижений в данной области. Достаточно сказать, что в 1980-е годы он был автором очень удачной и имевшей большое значение разработки — языка Turbo Pascal, изящная реализация которого послужила образцом для создания всех последующих компиляторов.

Язык C# непосредственно связан с С, C++ и Java. И это не случайно. Ведь это три самых широко распространенных и признанных во всем мире языка программирования. Кроме того, на момент создания C# практически все профессиональные программисты уже владели С, C++ или Java. Благодаря тому что C# построен на столь прочном и понятном основании, перейти на этот язык из С, C++ или Java не представляло особого труда. А поскольку и Хейльсбергу не нужно (да и нежелательно) было изобретать велосипед, то он мог сосредоточиться непосредственно на усовершенствованиях и нововведениях в С#.

На рис. 1.1 приведено генеалогическое дерево С#. Предком C# во втором поколении является С, от которого он унаследовал синтаксис, многие ключевые слова и операторы. Кроме того, C# построен на усовершенствованной объектной модели, определенной в C++. Если вы знаете С или C++, то будете чувствовать себя уютно и с языком С#.

Рис. 1.1. Генеалогическое дерево C#

Родственные связи C# и Java более сложные. Как пояснялось выше, Java также происходит от С и C++ и обладает общим с ними синтаксисом и объектной моделью. Как и Java, C# предназначен для получения переносимого кода, но C# не происходит непосредственно от Java. Напротив, C# и Java — это близкие, но не кровные родственники, имеющие общих предков, но во многом отличающиеся друг от друга. Впрочем, если вы знаете Java, то многие понятия C# окажутся вам знакомыми. С другой стороны, если вам в будущем придется изучать Java, то многие понятия, усвоенные в С#, могут быть легко распространены и на Java.

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

Развитие C#

С момента выпуска исходной версии 1.0 развитие C# происходило быстро. Вскоре после версии 1.0 корпорация Microsoft выпустила версию 1.1, в которую было внесено немало корректив, но мало значительных возможностей. Однако ситуация совершенно изменилась после выпуска версии C# 2.0.

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

Следующей значительной вехой в истории развития C# стал выпуск версии 3.0. В связи с внедрением многих новых свойств в версии C# 2.0 можно было ожидать некоторого замедления в развитии С#, поскольку программистам требовалось время для их освоения, но этого не произошло. С появлением версии 3.0 корпорация Microsoft внедрила ряд новшеств, совершенно изменивших общее представление о программировании. К числу этих новшеств относятся, среди прочего, лямбда-выражения, язык интегрированных запросов (LINQ), методы расширения и неявно типизированные переменные. Конечно, все эти новые возможности очень важны, поскольку они оказали заметное влияние на развитие данного языка, но среди них особенно выделяются две: язык интегрированных запросов (LINQ) и лямбда-выражения. Язык LINQ и лямбда-выражения вносят совершенно новый акцент в программирование на C# и еще глубже подчеркивают его ведущую роль в непрекращающейся эволюции языков программирования.

Текущей является версия C# 4.0, о которой и пойдет речь в этой книге. Эта версия прочно опирается на три предыдущие основные версии С#, дополняя их целым рядом новых средств. Вероятно, самыми важными среди них являются именованные и необязательные аргументы. В частности, именованные аргументы позволяют связывать аргумент с параметром по имени. А необязательные аргументы дают возможность указывать для параметра используемый по умолчанию аргумент. Еще одним важным новым средством является тип dynamic, применяемый для объявления объектов, которые проверяются на соответствие типов во время выполнения, а не компиляции. Кроме того, ковариантность и контравариантность параметров типа поддерживается благодаря новому применению ключевых слов in и out. Тем, кто пользуется моделью СОМ вообще и прикладными интерфейсами Office Automation API в частности, существенно упрощен доступ к этим средствам, хотя они и не рассматриваются в этой книге. В целом, новые средства, внедренные в версии C# 4.0, способствуют дальнейшей рационализации программирования и повышают практичность самого языка С#.

Еще два важных средства, внедренных в версии 4.0 и непосредственно связанных с программированием на С#, предоставляются не самим языком, а средой .NET Framework 4.0. Речь идет о поддержке параллельного программирования с помощью библиотеки распараллеливания задач (TPL) и параллельном варианте языка интегрированных запросов (PLINQ). Оба эти средства позволяют существенно усовершенствовать и упростить процесс создания программ, в которых применяется принцип параллелизма. И то и другое средство упрощает создание многопоточного кода, который масштабируется автоматически для использования нескольких процессоров, доступных на компьютере. В настоящее время широкое распространение получили компьютеры с многоядерными процессорами, и поэтому возможность распараллеливать выполнение кода среди всех доступных процессоров приобретает все большее значение практически для всех, кто программирует на С#. В силу этого особого обстоятельства средства TPL и PLINQ рассматриваются в данной книге.

Связь C# со средой .NET Framework

Несмотря на то что C# является самодостаточным языком программирования, у него имеется особая взаимосвязь со средой выполнения .NET Framework. Наличие такой взаимосвязи объясняется двумя причинами. Во-первых, C# первоначально предназначался для создания кода, который должен выполняться в среде .NET Framework. И во-вторых, используемые в C# библиотеки определены в среде .NET Framework. На практике это означает, что C# и .NET Framework тесно связаны друг с другом, хотя теоретически C# можно отделить от среды .NET Framework. В связи с этим очень важно иметь хотя бы самое общее представление о среде .NET Framework и ее значении для С#.

0 среде NET Framework

Назначение .NET Framework — служить средой для поддержки разработки и выполнения сильно распределенных компонентных приложений. Она обеспечивает совместное использование разных языков программирования, а также безопасность, переносимость программ и общую модель программирования для платформы Windows. Что же касается взаимосвязи с С#, то среда .NET Framework определяет два очень важных элемента. Первым из них является общеязыковая среда выполнения (Common Language Runtime — CLR). Это система, управляющая выполнением программ. Среди прочих преимуществ — CLR как составная часть среды .NET Framework поддерживает многоязыковое программирование, а также обеспечивает переносимость и безопасное выполнение программ.

Вторым элементом среды .NET Framework является библиотека классов. Эта библиотека предоставляет программе доступ к среде выполнения. Так, если требуется выполнить операцию ввода-вывода, например вывести что-нибудь на экран, то для этой цели используется библиотека классов .NET. Для тех, кто только начинает изучать программирование, понятие класса может оказаться незнакомым. Оно подробно разъясняется далее в этой книге, а пока достаточно сказать, что класс — это объектно-ориентированная конструкция, помогающая организовать программы. Если программа ограничивается средствами, определяемыми в библиотеке классов .NET, то такая программа может выполняться везде, где поддерживается среда выполнения .NET. А поскольку в C# библиотека классов .NET используется автоматически, то программы на C# заведомо оказываются переносимыми во все имеющиеся среды .NET Framework.

Принцип действия CLR

Среда CLR управляет выполнением кода .NET. Действует она по следующему принципу. Результатом компиляции программы на C# является не исполняемый код, а файл, содержащий особого рода псевдокод, называемый Microsoft Intermediate Language, MSIL (промежуточный язык Microsoft). Псевдокод MSIL определяет набор переносимых инструкций, не зависящих от конкретного процессора. По существу, MSIL определяет переносимый язык ассемблера. Следует, однако, иметь в виду, что, несмотря на кажущееся сходство псевдокода MSIL с байт-кодом Java, это все же разные понятия.

Назначение CLR — преобразовать промежуточный код в исполняемый код по ходу выполнения программы. Следовательно, всякая программа, скомпилированная в псевдокод MSIL, может быть выполнена в любой среде, где имеется реализация CLR. Именно таким образом отчасти достигается переносимость в среде .NET Framework.

Псевдокод MSIL преобразуется в исполняемый код с помощью ]1Т-компилятора. Сокращение JIT означает точно в срок и отражает оперативный характер данного компилятора. Процесс преобразования кода происходит следующим образом. При выполнении программы среда CLR активизирует JIT-компилятор, который преобразует псевдокод MSIL в собственный код системы по требованию для каждой части программы. Таким образом, программа на C# фактически выполняется как собственный код, несмотря на то, что первоначально она скомпилирована в псевдокод MSIL. Это означает, что такая программа выполняется так же быстро, как и в том случае, когда она исходно скомпилирована в собственный код, но в то же время она приобретает все преимущества переносимости псевдокода MSIL.

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

Управляемый и неуправляемый код

Как правило, при написании программы на C# формируется так называемый управляемый код. Как пояснялось выше, такой код выполняется под управлением среды CLR, и поэтому на него накладываются определенные ограничения, хотя это и дает ряд преимуществ. Ограничения накладываются и удовлетворятся довольно просто: ком пи-лятор должен сформировать файл MSIL, предназначенный для выполнения в среде CLR, используя при этом библиотеку классов .NET, — и то и другое обеспечивается средствами С#. Ко многим преимуществам управляемого кода относятся, в частности, современные способы управления памятью, возможность программирования на разных языках, повышение безопасности, поддержка управления версиями и четкая организация взаимодействия программных компонентов.

В отличие от управляемого кода, неуправляемый код не выполняется в среде CLR. Следовательно, до появления среды .NET Framework во всех программах для Windows применялся неуправляемый код. Впрочем, управляемый и неуправляемый коды могут взаимодействовать друг с другом, а значит, формирование управляемого кода в C# совсем не означает, что на его возможность* взаимодействия с уже существующими программами накладываются какие-то ограничения.

Общеязыковая спецификация

Несмотря на все преимущества, которые среда CLR дает управляемому коду, для максимального удобства его использования вместе с программами, написанными на других языках, он должен подчинятся общеязыковой спецификации (Common Language Specification — CLS), которая определяет ряд общих свойств для разных .NET-совместимых языков. Соответствие CLS особенно важно при создании программных компонентов, предназначенных для применения в других языках. В CLS в качестве подмножества входит общая система типов (Common Type System — CTS), в которой определяются правила, касающиеся типов данных. И разумеется, в C# поддерживается как CLS, так и CTS.

ГЛАВА 2 Краткий обзор элементов C#

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

Объектно-ориентированное программирование

Основным понятием C# является объектно-ориентированное программирование (ООП). Методика ООП неотделима от С#, и поэтому все программы на C# являются объектно-ориентированными хотя бы в самой малой степени. В связи с этим очень важно и полезно усвоить основополагающие принципы ООП, прежде чем приступать к написанию самой простой программы на С#.

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

компьютера, постепенно приспосабливаясь, главным образом, к повышению сложности программ. Когда, например, появились первые ЭВМ, программирование заключалось в ручном переключении на разные двоичные машинные команды с переднего пульта управления ЭВМ. Такой подход был вполне оправданным, поскольку программы состояли всего из нескольких сотен команд. Дальнейшее усложнение программ привело к разработке языка ассемблера, который давал программистам возможность работать с более сложными программами, используя символическое представление отдельных машинных команд. Постоянное усложнение программ вызвало потребность в разработке и внедрении в практику программирования таких языков высокого уровня, как, например, FORTRAN и COBOL, которые предоставляли программистам больше средств для того, чтобы как-то справиться с постоянно растущей сложностью программ. Но как только возможности этих первых языков программирования были полностью исчерпаны, появились разработки языков структурного программирования, в том числе и С.

На каждом этапе развития программирования появлялись методы и инструментальные средства для "обуздания" растущей сложности программ. И на каждом таком этапе новый подход вбирал в себя все самое лучшее из предыдущих, знаменуя собой прогресс в программировании. Это же можно сказать и об ООП. До ООП многие проекты достигали (а иногда и превышали) предел, за которым структурный подход к программированию оказывался уже неработоспособным. Поэтому для преодоления трудностей, связанных с усложнением программ, и возникла потребность в ООП.

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

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

Для поддержки принципов ООП все объектно-ориентированные языки программирования, в том числе и С#, должны обладать тремя общими свойствами: инкапсуляцией, полиморфизмом и наследованием. Рассмотрим каждое из этих свойств в отдельности.

Инкапсуляция

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

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

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

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

Полиморфизм

Полиморфизм, что по-гречески означает "множество форм", — это свойство, позволяющее одному интерфейсу получать доступ к общему классу действий. Простым примером полиморфизма может служить руль автомашины, который выполняет одни и те же функции своеобразного интерфейса независимо от вида применяемого механизма управления автомашиной. Это означает, что руль действует одинаково независимо от вида рулевого управления: прямого действия, с усилением или реечной передачей. Следовательно, при вращении руля влево автомашина всегда поворачивает влево, какой бы вид управления в ней ни применялся. Главное преимущество единообразного интерфейса заключается в том, что, зная, как обращаться с рулем, вы сумеете водить автомашину любого типа.

Тот же самый принцип может быть применен и в программировании. Рассмотрим для примера стек, т.е. область памяти, функционирующую по принципу "последним пришел — первым обслужен". Допустим, что в программе требуются три разных типа стеков: один — для целых значений, другой — для значений с плавающей точкой, третий — для символьных значений. В данном примере алгоритм, реализующий все эти стеки, остается неизменным, несмотря на то, что в них сохраняются разнотипные данные. В языке, не являющемся объектно-ориентированным, для этой цели пришлось бы создать три разных набора стековых подпрограмм с разными именами. Но благодаря полиморфизму для реализации всех трех типов стеков в C# достаточно создать лишь один общий набор подпрограмм. Зная, как пользоваться одним стеком, вы сумеете воспользоваться и остальными.

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

Наследование

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

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

Первая простая программа

А теперь самое время перейти к примеру конкретной программы на С#. Для начала скомпилируем и выполним короткую программу.

/*

Это простая программа на С#.

Назовем ее Example.cs.

*/

using System;

class Example {

// Любая программа на C# начинается с вызова метода Main(). static void Main() {

Console.WriteLine("Простая программа на С#.");

}

}

Основной средой для разработки программ на C# служит Visual Studio корпорации Microsoft. Для компилирования примеров всех программ, приведенных для примера в этой книге, в том числе и тех, где используются новые средства C# 4.0, вам потребуется Visual Studio 2010 или же более поздняя версия, поддерживающая С#.

Создавать, компилировать и выполнять программы на С#, используя Visual Studio, можно двумя способами: пользуясь, во-первых, интегрированной средой разработки Visual Studio, а во-вторых, — компилятором командной строки csc . ехе. Далее описываются оба способа.

Применение компилятора командной строки csc. ехе

Для коммерческой разработки программ вам, скорее всего, придется пользоваться интегрированной средой Visual Studio, хотя для некоторых читателей более удобным может оказаться компилятор, работающий в режиме командной строки, особенно для компилирования и выполнения примеров программ, приведенных в этой книге. Объясняется это тем, что для работы над отдельной программой не нужно создавать целый проект. Для этого достаточно написать программу, а затем скомпилировать и выполнить ее, причем все это делается из командной строки. Таким образом, если вы умеете пользоваться окном Командная строка (Command Prompt) и его интерфейсом в Windows, то компилятор командной строки окажется для вас более простым и оперативным инструментальным средством, чем интегрированная среда разработки.

ПРЕДОСТЕРЕЖЕНИЕ

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

Для написания и выполнения программ на C# с помощью компилятора командной строки выполните следующую несложную процедуру.

1'. Введите исходный текст программы, используя текстовый редактор.

2.    Скомпилируйте программу с помощью компилятора csc . ехе.

3.    Выполните программу.

Ввод исходного текста программы

Исходный текст примеров программ, приведенных в этой книге, доступен для загрузки по адресу www. mhprof es-sional. com. Но при желании вы можете сами ввести исходный текст этих программ вручную. Для этого воспользуйтесь избранным текстовым редактором, например Notepad. Но не забывайте, что вы должны создать файлы, содержащие простой, а не отформатированный текст, поскольку информация форматирования текста, сохраняемая в файле для обработки текста, может помешать нормальной работе компилятора С#. Введя исходный текст программы, присвойте ее файлу имя Example. cs.

Компилирование программы

Для компилирования программы на C# запустите на выполнение компилятор csc. ехе, указав имя исходного файла в командной строке.

C:\>csc Example.cs

Компилятор csc создаст файл Example . ехе, содержащий версию MSIL данной программы. Несмотря на то что псевдокод MSIL не является исполняемым кодом, он содержится в исполняемом файле с расширением . ехе. Среда CLR автоматически вызывает JIT-компилятор при попытке выполнить файл Example . ехе. Следует, однако, иметь в виду, что если попытаться выполнить файл Example . ехе (или любой другой исполняемый файл, содержащий псевдокод MSIL) на том компьютере, где среда .NET Framework не установлена, то программа не будет выполнена, поскольку на этом компьютере отсутствует среда CLR.

ПРИМЕЧАНИЕ

Прежде чем запускать на выполнение компилятор csc. ехе, откройте окно Командная строка, HacTpoeHHoenoAVisualStudio. Для этого проще всего выбрать команду Visual Studios Инструменты Visual Э^ю^Командная строка Visual Studio (Visual Studio^Visual Studio Tools^Visual Studio Command Prompt) из меню Пуск^Все программы (Start^AII Programs) на панели задач Windows. Кроме того, вы можете открыть ненастроенное окно Командная строка, а затем выполнить командный файл vsvars32.bat, входящий в состав Visual Studio.

Выполнение программы

Для выполнения программы введите ее имя в командной строке следующим образом.

С:\>Ехашр1е

В результате выполнения программы на экране появится такая строка.

Простая программа на С#.

Применение интегрированной среды разработки Visual Studio

Visual Studio представляет собой интегрированную среду разработки программ, созданную корпорацией Microsoft. Такая среда дает возможность править, компилировать, выполнять и отлаживать программы на С#, не покидая эту грамотно организованную среду. Visual Studio предоставляет не только все необходимые средства для работы с программами, но и помогает правильно организовать их. Она оказывается наиболее эффективной для работы над крупными проектами, хотя может быть с тем же успехом использована и для разработки небольших программ, например, тех, которые приведены в качестве примера в этой книге.

Ниже приведена краткая процедура правки, компилирования и выполнения программы на C# в интегрированной среде разработки Visual Studio 2010. При этом предполагается, что интегрированная среда разработки входит в состав пакета Visual Studio 2010 Professional. В других версиях Visual Studio возможны незначительные отличия.

1. Создайте новый (пустой) проект С#, выбрав команду Файл■=>Создать1^ Проект (File ■=> New ^Project). Затем выберите элемент Windows из списка Установленные шаблоны (Installed Templates) и далее — шаблон Пустой проект (Empty Project), как показано на рисунке.

ПРИМЕЧАНИЕ

Имя и местоположение вашего проекта может отличаться от того, что показано здесь.

Щелкните на кнопке ОК, чтобы создать проект.

После создания нового проекта среда Visual Studio будет выглядеть так, как показано на рисунке.

Если по какой-либо причине окно Обозреватель решений (Solution Explorer) будет отсутствовать, откройте его с помощью команды ВидООбозреватель решений (View^Solution Explorer).

На данном этапе проект пуст, и вам нужно ввести в него файл с исходным текстом программы на С#. Для этого щелкните правой кнопкой мыши на имени проекта (в данном случае — Project 1) в окне Обозреватель решений, а затем выберите команду Добавить (Add) из контекстного меню. В итоге появится подменю, показанное на рисунке.

Выберите команду Создать элемент (New Item), чтобы открыть диалоговое окно Добавление нового элемента (Add New Item). Выберите сначала элемент Код (Code) из списка Установленные шаблоны, а затем шаблон Файл с текстом программы (Code File) и измените имя файла на Example. cs, как показано на рисунке.

5. Введите выбранный файл в проект, щелкнув на кнопке Добавить. После этого экран будет выглядеть так, как показано на рисунке.

6. Введите исходный текст программы в окне с меткой Example. cs, после чего сохраните этот текст в файле. (Исходный текст примеров программ, приведенных в этой книге, можно свободно загрузить по адресу www.mhprofessional. com, чтобы не вводить его каждый раз вручную.) По завершении ввода исходного текста программы экран будет выглядеть так, как показано на рисунке.

7.    Скомпилируйте программу, выбрав команду Построением Построить решение (Build1=>Build Solution).

8.    Выполните программу, выбрав команду Отладка ^Запуск без отладки (Debug^Start Without Debugging). В результате выполнения программы откроется окно, показанное на рисунке.

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

ПРИМЕЧАНИЕ

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

Построчный анализ первого примера программы

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

В отличие от ряда других языков программирования, и в особенности Java, где имя файла программы имеет большое значение, имя программы на C# может быть произвольным. Ранее вам было предложено присвоить программе из первого примера имя Exa'mple . cs, чтобы успешно скомпилировать и выполнить ее, но в C# файл с исходным текстом этой программы можно было бы назвать как угодно. Например, его можно было назвать Sample. cs, Test. cs или даже X. cs.

В файлах с исходным текстом программ на C# условно принято расширение . cs, и это условие вы должны соблюдать. Кроме того, многие программисты называют файлы с исходным текстом своих программ по имени основного класса, определенного в программе. Именно поэтому в рассматриваемом здесь примере было выбрано имя файла Example. cs. Но поскольку имена программ на C# могут быть произвольными, то они не указываются в большинстве примеров программ, приведенных в настоящей книге. Поэтому вы вольны сами выбирать для них имена.

Итак, анализируемая программа начинается с таких строк.

/*

Это простая программа на С#.

Назовем ее Example.cs.

*/

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

В C# поддерживаются три стиля комментариев. Один из них приводится в самом начале программы и называется многострочным комментарием. Этот стиль комментария должен начинаться символами /* и оканчиваться символами */. Все, что находится между этими символами, игнорируется компилятором. Как следует из его названия, многострочный комментарий может состоять из нескольких строк.

Рассмотрим следующую строку программы.

using System;

Эта строка означает, что в программе используется пространство имен System. В C# пространство имен определяет область объявлений. Подробнее о пространстве имен речь пойдет далее в этой книге, а до тех пор поясним вкратце его назначение. Благодаря пространству имен одно множество имен отделяется от других. По существу, имена, объявляемые в одном пространстве имен, не вступают в конфликт с именами, объявляемыми в другом пространстве имен. В анализируемой программе используется пространство имен System, которое зарезервировано для элементов, связанных с библиотекой классов среды .NET Framework, применяемой в С#. Ключевое слово using просто констатирует тот факт, что в программе используются имена в заданном пространстве имен. (Попутно обратим внимание на весьма любопытную возможность создавать собственные пространства имен, что особенно полезно для работы над крупными проектами.)

Перейдем к следующей строке программы.

class Example {

В этой строке ключевое слово class служит для объявления вновь определяемого класса. Как упоминалось выше, класс является основной единицей инкапсуляции в С#, a Example — это имя класса. Определение класса начинается с открывающей фигурной скобки ({) и оканчивается закрывающей фигурной скобкой (}). Элементы, заключенные в эти фигурные скобки, являются членами класса. Не вдаваясь пока что в подробности, достаточно сказать, что в C# большая часть действий, выполняемых в программе, происходит именно в классе.

Следующая строка программы содержит однострочный комментарий.

// Любая программа на C# начинается с вызова метода Main().

Это второй стиль комментариев, поддерживаемых в С#. Однострочный комментарий начинается и оканчивается символами //. Несмотря на различие стилей комментариев, программисты нередко пользуются многострочными комментариями для более длинных примечаний и однострочными комментариями для коротких, построчных примечаний к программе. (Третий стиль комментариев, поддерживаемых в С#, применяется при создании документации и описывается в приложении А.)

Перейдем к анализу следующей строки программы.

static void Main() {

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

Данная строка начинается с ключевого слова static. Метод, определяемый ключевым словом static, может вызываться до создания объекта его класса. Необходимость в этом объясняется тем, что метод Main () вызывается при запуске программы. Ключевое слово void указывает на то, что метод Main () не возвращает значение. В дальнейшем вы узнаете, что методы могут также возвращать значения. Пустые круглые скобки после имени метода Main означают, что этому методу не передается никакой информации. Теоретически методу Main () можно передать информацию, но в данном примере этого не делается. И последним элементом анализируемой строки является символ {, обозначающий начало тела метода Main (). Весь код, составляющий тело метода, находится между открывающими и закрывающими фигурными скобками.

Рассмотрим следующую строку программы. Обратите внимание на то, что она находится внутри метода Main ().

Console.WriteLine("Простая программа на С#.");

В этой строке осуществляется вывод на экран текстовой строки "Простая программа на C# . Сам вывод выполняется встроенным методом WriteLine (). В данном примере метод WriteLine () выводит на экран строку, которая ему передается. Информация, передаваемая методу, называется аргументом. Помимо текстовых строк, метод WriteLine () позволяет выводить на экран другие виды информации. Анализируемая строка начинается с Console — имени предопределенного класса, поддерживающего ввод-вывод на консоль. Сочетание обозначений Console и WriteLine () указывает компилятору на то, что метод WriteLine () является членом класса Console. Применение в C# объекта для определения вывода на консоль служит еще одним свидетельством объектно-ориентированного характера этого языка программирования.

Обратите внимание на то, что оператор, содержащий вызов метода WriteLine (), оканчивается точкой с запятой, как, впрочем, и рассматривавшаяся ранее директива using System. Как правило, операторы в C# оканчиваются точкой с запятой. Исключением из этого правила служат блоки, которые начинаются символом { и оканчиваются символом }. Именно поэтому строки программы с этими символами не оканчиваются точкой с запятой. Блоки обеспечивают механизм группирования операторов и рассматриваются далее в этой главе.

Первый символ } в анализируемой программе завершает метод Main (), а второй — определение класса Example.

И наконец, в C# различаются прописные и строчные буквы. Несоблюдение этого правила может привести к серьезным осложнениям. Так, если вы неумышленно наберете main вместо Main или же writeline вместо WriteLine, анализируемая программа окажется ошибочной. Более того, компилятор C# не предоставит возможность выполнить классы, которые не содержат метод Main (), хотя и скомпилирует их. Поэтому если вы неверно наберете имя метода Main, то получите от компилятора сообщение об ошибке, уведомляющее о том, что в исполняемом файле Example. ехе не определена точка входа.

Обработка синтаксических ошибок

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

Несмотря на всю полезность сообщений о синтаксических ошибках, выдаваемых компилятором, они иногда вводят в заблуждение. Ведь компилятор C# пытается извлечь какой-то смысл из исходного текста, как бы он ни был набран. Именно по этой причине ошибка, о которой сообщает компилятор, не всегда отражает настоящую причину возникшего затруднения. Неумышленный пропуск открывающей фигурной скобки после метода Main () в рассмотренном выше примере программы приводит к появлению приведенной ниже последовательности сообщений об ошибках при компиляции данной программы компилятором командной строки с sc. (Аналогичные ошибки появляются при компиляции в интегрированной среде разработки Visual Studio.)

EXl.CS (12,21): ошибка CS1002: ; ожидалось

EXl.CS(13,22): ошибка CS1519: Недопустимая лексема '(' в

объявлении члена класса, структуры или интерфейса

EXl.CS(15,1): ошибка CS1022: Требуется определение типа

или пространства имен либо признак конца файла

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

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

Незначительное изменение программы

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

using System;

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

Console.WriteLine("Простая программа на С#."); можно переписать следующим образом.

System.Console.WriteLine("Простая программа на С#.");

Таким образом, первый пример программы можно видоизменить так.

// В эту версию не включена строка "using System;".

class Example {

// Любая программа на C# начинается с вызова метода Main(). static void Main() {

// Здесь имя Console.WriteLine полностью определено.

System.Console.WriteLine("Простая программа на С#.");

}

}

Указывать пространство имен System всякий раз, когда используется член этого пространства, — довольно утомительное занятие, и поэтому большинство программистов на C# вводят директиву using System в начале своих программ, как это сделано в примерах всех программ, приведенных в данной книге. Следует, однако, иметь в виду, что любое имя можно всегда определить, явно указав его пространство имен, если в этом есть необходимость.

Вторая простая программа

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

В приведенной ниже программе создаются две переменные — х и у.

// Эта программа демонстрирует применение переменных.

using System;    *

class Example2 {

static void Main() {

int x; // здесь объявляется переменная

int у; // здесь объявляется еще одна переменная

х = 100; // здесь переменной х присваивается значение 100

Console.WriteLine("х содержит " + х);

у = х / 2;

Console.Write("у содержит х / 2: ");

Console.WriteLine(у);

}

}

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

х содержит 100 у содержит х / 2: 50

В этой программе вводится ряд новых понятий. Прежде всего, в операторе

int х; // здесь объявляется переменная

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

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

int у; // здесь объявляется еще одна переменная

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

В целом, для объявления переменной служит следующий оператор:

тип имя_переменной;

где тип — это конкретный тип объявляемой переменной, а имя_переменной — имя самой переменной. Помимо типа int, в C# поддерживается ряд других типов данных. В следующей строке программы переменной х присваивается значение 100.

х = 100; // здесь переменной х присваивается значение 100    ,

В C# оператор присваивания обозначается одиночным знаком равенства (=). Данный оператор выполняет копирование значения, расположенного справа от знака равенства, в переменную, находящуюся слева от него.

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

Console.WriteLine("х содержит " + х);

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

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

у = х / 2;

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

+

Сложение

-

Вычитание

*

Умножение

/

Деление

Рассмотрим две оставшиеся строки программы.

Console.Write("у содержит х / 2: ");

Console.WriteLine(у);

В этих строках обнаруживаются еще две особенности. Во-первых, для вывода текстовой строки "у содержит х / 2 :    11 на экран используется встроенный метод

Write (). После этой текстовой строки новая строка не следует. Это означает, что последующий вывод будет осуществлен в той же самой строке. Метод Write () подобен методу WriteLine (), за исключением того, что после каждого его вызова вывод не начинается с новой строки. И во-вторых, обратите внимание на то, что в вызове метода WriteLine () указывается только переменная у. Оба метода, Write () nWriteLine (), могут быть использованы для вывода значений любых встроенных в C# типов.

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

int х, у; // обе переменные объявляются в одном операторе

ПРИМЕЧАНИЕ

В C# внедрено средство, называемое неявно типизированной переменной. Неявно типизированными являются такие переменные, тип которых автоматически определяется компилятором. Подробнее неявно типизированные переменные рассматриваются в главе 3.

Другие типы данных

В предыдущем примере программы использовались переменные типа int. Но в переменных типа int могут храниться только целые числа. Их нельзя использовать в операциях с числами, имеющими дробную часть. Например, переменная типа int может содержать значение 18, но не значение 18,3. Правда, int — далеко не единственный тип данных, определяемых в С#. Для операций с числами, имеющими дробную часть, в C# предусмотрены два типа данных с плавающей точкой: float и double. Они обозначают числовые значения с одинарной и двойнЬй точностью соответственно. Из этих двух типов чаще всего используется тип double.

Для объявления переменной типа double служит оператор

double result;

где result — это имя переменной типа double. А поскольку переменная result имеет тип данных с плавающей точкой, то в ней могут храниться такие числовые значения, как, например, 122,23, 0,034 или -19,0.

Для лучшего понимания.отличий между типами данных int и double рассмотрим такой пример программы.

/*

Эта программа демонстрирует отличия между типами данных int и double.

*/

using System;

class Example3 {

static void Main() {

int ivar; // объявить целочисленную переменную double    dvar; // объявить    переменную    с    плавающей    точкой

ivar =    100;    // присвоить    переменной    ivar    значение    100

dvar = 100.0; // присвоить переменной dvar значение 100.0

Console.WriteLine("Исходное значение ivar: " + ivar);

Console.WriteLine("Исходное значение dvar: " + dvar);

Console.WriteLine(); // вывести пустую строку

// Разделить значения обеих переменных на 3. ivar =    ivar    / 3;

dvar =    dvar    / 3.0; -

Console.WriteLine("Значение ivar после деления: " + ivar);

Console.WriteLine("Значение dvar после деления: " + dvar);

}

}

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

Исходное значение ivar: 100 Исходное значение dvar: 100

Значение ivar после деления: 33

Значение dvar после деления: 33.3333333333333

Как видите, при делении значения переменной ivar типа int на 3 остается лишь целая часть результата — 33, а дробная его часть теряется. В то же время при делении значения переменной dvar типа double на 3 дробная часть результата сохраняется.

Как демонстрирует данный пример программы, в числовых значениях с плавающей точкой следует использовать обозначение самой десятичной точки. Например, значение 100 в C# считается целым, а значение 100,0 — с плавающей точкой.

В данной программе обнаруживается еще одна особенность. Для вывода пустой строки достаточно вызвать метод WriteLine () без аргументов.

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

// Вычислить площадь круга.

using System;

class Circle {

static void Main() { double radius; double area;

radius = 10.0;

area = radius * radius * 3.1416;

Console.WriteLine("Площадь равна " + area);

}

}

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

Площадь равна 314.16

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

Два управляющих оператора

Выполнение программы внутри метода (т.е. в его теле) происходит последовательно от одного оператора к другому, т.е. по цепочке сверху вниз. Этот порядок выполнения программы можно изменить с помощью различных управляющих операторов, поддерживаемых в С#. Более подробно управляющие операторы будут рассмотрены в дальнейшем, а здесь они представлены вкратце, поскольку используются в последующих примерах программ.

Условный оператор

С помощью условного оператора if в C# можно организовать выборочное выполнение части программы. Оператор if действует в C# практически так же, как и оператор IF в любом другом языке программирования. В частности, с точки зрения синтаксиса он тождествен операторам i f в С, C++ и Java. Ниже приведена простейшая форма этого оператора.

if (условие) оператор;

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

if (10 < 11) Console . WriteLine (1110 меньше 11м);

В данном примере условное выражение принимает истинное значение, поскольку 10 меньше 11, и поэтому метод WriteLine () выполняется. А теперь рассмотрим другой пример.

if(10 < 9) Console.WriteLine ("не подлежит выводу");

В данном примере 10 не меньше 9. Следовательно, вызов метода WriteLine () не произойдет.

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

Операция

Значение

<

Меньше

<=

Меньше или равно

>

Больше

>=

Больше или равно

==

Равно

i =

Не равно

Далее следует пример еще одной программы, демонстрирующей применение условного оператора if.

// Продемонстрировать применение условного оператора if.

using System;

class IfDemo {

static void Main() { int a, b, c;

a = 2; b = 3;

if(a < b) Console.WriteLine("а меньше b");

// He подлежит выводу.

if(a == b) Console.WriteLine("этого никто не увидит");

Console.WriteLine(); c=a-b; //с содержит -1

Console.WriteLine("с содержит -Iм);

if(с >= 0) Console.WriteLine("значение с неотрицательно"); if(с < 0) Console.WriteLine("значение с отрицательно");

Console.WriteLine();

с = b - а; // теперь с содержит 1 Console.WriteLine("с содержит 1");

if(с >= 0) Console.WriteLine("значение с неотрицательно"); if(с < 0) Console.WriteLine ("значение с отрицательно ");

}

}

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

а меньше b

с содержит -1 значение с отрицательно

с содержит 1

значение с неотрицательно

Обратите внимание на еще одну особенность этой программы. В строке

int а, Ь, с;

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

Оператор цикла

Для повторного выполнения последовательности операций в программе можно организовать цикл. Язык C# отличается большим разнообразием циклических конструкций. Здесь будет рассмотрен оператор цикла for. Как и у оператора if, у оператора f or в C# имеются аналоги в С, C++ и Java. Ниже приведена простейшая форма этого оператора.

for (инициализация; условие; итерация) оператор;

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

// Продемонстрировать применение оператора цикла- for. using System; class ForDemo {

static void Main() { int count;

for (count = 0; count < 5; count = count+1)

Console.WriteLine("Это подсчет: " + count);

Console.WriteLine("Готово!");

}

}

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

Это подсчет: 0 Это подсчет: 1 Это подсчет: 2 Это подсчет: 3 Это подсчет: 4 Готово!

В данном примере count выполняет роль переменной управления циклом. В инициализирующей части оператора цикла for задается нулевое значение этой переменной. В начале каждого шага цикла, включая и первый, проверяется условие count 5. Если эта проверка дает истинный результат, то выполняется оператор, содержащий метод WriteLine (). Далее выполняется итерационная часть оператора цикла for, где значение переменной count увеличивается на 1. Этот процесс повторяется до тех пор, пока значение переменной count не достигнет величины 5. В этот момент проверка упомянутого выше условия дает ложный результат, что приводит к завершению цикла. Выполнение программы продолжается с оператора, следующего после цикла.

Любопытно, что в программах, профессионально написанных на С#, вы вряд ли увидите итерационную часть оператора цикла в том виде, в каком она представлена в приведенном выше примере программы, т.е. вы редко встретите следующую строку.

count = count +1;    •

Дело в том, что в C# имеется специальный оператор инкремента, выполняющий приращение на 1 значение переменной, или так называемого операнда. Этот оператор обозначается двумя знаками + (++). Используя оператор инкремента, можно переписать приведенную выше строку следующим образом.

count++;

Таким образом, оператор цикла for из приведенного выше примера программы обычно записывается в следующем виде.

for (count = 0; count < 5; count++)

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

В C# имеется также оператор декремента, обозначаемый двумя дефисами (—). Этот оператор уменьшает значение операнда на 1.

Использование кодовых блоков

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

if(w < h) { v = w * h; w = 0;

}

Если в данном примере кода значение переменной w меньше значения переменной h, то оба оператора выполняются в кодовом блоке. Они образуют внутри кодового блока единый логический элемент, причем один не может выполняться без другого. Таким образом, если требуется логически связать два (или более) оператора, то для этой цели следует создать кодовый блок. С помощью кодовых блоков можно более эффективно и ясно реализовать многие алгоритмы.    /

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

// Продемонстрировать применение кодового блока.

using System;

class BlockDemo {

static void Main() { int i, j, d;

i = 5; j = 10;

// Адресатом этого оператора if служит кодовый блок, if(i != 0) {

Console.WriteLine ("i не равно нулю"); d = j / i;

Console.WriteLine("j / i равно " + d);

}

}

}

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

i не равно нулю j / i равно 2

В данном примере адресатом оператора if служит кодовый блок, а не единственный оператор. Если условие, управляющее оператором i f, оказывается истинным, то выполняются три оператора в кодовом блоке. Попробуйте задать нулевое значение переменной i, чтобы посмотреть, что из этого получится.

Рассмотрим еще один пример, где кодовый блок служит для вычисления суммы и произведения чисел от 1 до 10.

// Вычислить сумму и произведение чисел от 1 до 10.

using System;

class ProdSum {

static void Main() { int prod; int sum; int i;

sum = 0; prod = 1;

for (i=l; i <= 10; i++)    {

sum = sum + i; prod = prod * i;

}

Console.WriteLine("Сумма равна " + sum);

Console.WriteLine("Произведение равно " + prod);

}

}

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

Сумма равна 55 Произведение равно 362880 0

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

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

Точка с запятой и оформление исходного текста программы

В C# точка с запятой обозначает конец оператора. Это означает, что каждый оператор в отдельности должен оканчиваться точкой с запятой.

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

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

X = у; у = у + 1;

Console.WriteLine(х + " " + у); означают то же самое, что и строка кода

х = у; у = у + 1; Console.WriteLine(х + " " + у);

Более того, составные элементы оператора можно располагать в отдельных строках. Например, следующий фрагмент кода считается в C# вполне допустимым.

Console.WriteLine("Это длинная строка вывода" + х + у + z +

"дополнительный вывод");

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

Возможно, вы уже обратили внимание на то, что в предыдущих примерах программ некоторые операторы были набраны с отступом. В C# допускается свободная форма записи. Это означает, что взаимное расположение операторов в строке не имеет особого значения. Но с годами в программировании сложился общепринятый стиль оформления исходного текста программ с отступами, что существенно облегчает чтение этого текста. Именно этому стилю следуют примеры программ в данной книге, что рекомендуется делать и вам. В соответствии с этим стилем следует делать отступ (в виде нескольких пробелов) после каждой открывающей фигурной скобки и возвращаться назад после закрывающей фигурной скобки. А для некоторых операторов даже требуется дополнительный отступ, но об этом речь пойдет далее.

Ключевые слова C#

Основу любого языка программирования составляют его ключевые слова, поскольку они определяют средства, встроенные в этот язык. В C# определены два общих типа ключевых слов: зарезервированные и контекстные. Зарезервированные ключевые слова нельзя использовать в именах переменных, классов или методов. Их можно использовать только в качестве ключевых слов. Именно поэтому они и называются зарезервированными. Их иногда еще называют зарезервированными словами, или зарезервированными идентификаторами. В настоящее время в версии 4.0 языка C# определено 77 зарезервированных ключ^евых слов (табл. 2.1).

Таблица 2.1. Ключевые слова, зарезервированные в языке C#

abstract

as

base

bool

break

byte

case

catch

char

checked

class

const

continue

decimal

default

delegate

do

double

else

enum

event

explicit

extern

false

finally

fixed

float

for

foreach

goto

if

implicit

in

int

interface

internal

is

lock

long

namespace

new

null

object

operator

out

override

params

private

protected

public

readonly

ref

return

sbyte

sealed

short

sizeof

stackalloc

static

string

struct

switch

this

throw

true

try

typeof

uint

ulong

unchecked

unsafe

ushort

using

virtual

volatile

void

while

Кроме того, в версии C# 4.0 определены 18 контекстных ключевых слов, которые приобретают особое значение в определенном контексте. В таком контексте они выполняют роль ключевых слов, а вне его они могут использоваться в именах других элементов программы, например в именах переменных. Следовательно, контекстные ключевые слова*формально не являются зарезервированными. Но, как правило, их следует считать зарезервированными, избегая их применения в любых других целях. Ведь применение контекстного ключевого слова в качестве имени какого-нибудь другого элемента программы может привести к путанице, и поэтому считается многими программистами плохой практикой. Контекстные ключевые слова приведены в табл. 2.2.

Таблица 2.2. Контекстные ключевые слова в C#

add

dynamic

from

get

global

group

into

j oin

let

orderby

partial

remove

select

set

value

var

where

yield

Идентификаторы

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

зарезервированы для применения в компиляторе. Прописные и строчные буквы в C# различаются. Так, например myvar и MyVar — это разные имена переменных. Ниже приведены некоторые примеры допустимых идентификаторов.

Test

X

У2

MaxLoad

up

top

my var

sample23

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

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

// Продемонстрировать применение идентификатора со знаком

using System;

class IdTest {

static void Main() { int @if; // применение ключевого слова if

//в качестве идентификатора

for(@if = 0; @if < 10; @if++)

Console . Writ-eLine ( "@if равно " + @if) ;

}

}

Приведенный ниже результат выполнения этой программы подтверждает, что @if правильно интерпретируется в качестве идентификатора.

@if равно 0 @if равно 1 @if равно 2 @if равно 3 @if равно 4 @if равно 5 @if равно 6 @if равно 7 @if равно 8 @if равно 9

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

Библиотека классов среды .NET Framework

В примерах программ, представленных в этой главе, применялись два встроенных метода: WriteLine () и Write (). Как упоминалось выше, эти методы являются членами класса Console, относящегося к пространству имен System, которое определяется в библиотеке классов для среды .NET Framework. Ранее в этой главе пояснялось, что среда C# опирается на библиотеку классов, предназначенную для среды .NET Framework, чтобы поддерживать операции ввода-вывода, обработку строк, работу в сети и графические пользовательские интерфейсы. Поэтому, вообще говоря, C# представляет собой определенное сочетание самого языка C# и стандартных классов .NET. Как будет показано далее, библиотека классов обеспечивает функциональные возможности, являющиеся неотъемлемой частью любой программы на С#. Для того чтобы научиться программировать на С#, нужно знать не только сам язык, но и уметь пользоваться стандартными классами. Различные элементы библиотеки классов для среды .NET Framework рассматриваются в части I этой книги, а в части II — сама библиотека по отдельным ее составляющим.

ГЛАВА 3 Типы данных, литералы и переменные

В этой главе рассматриваются три основополагающих элемента С#: типы данных, литералы и переменные.

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

О значении типов данных

Типы данных имеют особенное значение в С#, поскольку это строго типизированный язык. Это означает, что все операции подвергаются строгому контролю со стороны компилятора на соответствие типов, причем недопустимые операции не компилируются. Следовательно, строгий контроль типов позволяет исключить ошибки и повысить надежность программ. Для обеспечения контроля типов все переменные, выражения и значения должны принадлежать к определенному типу. Такого понятия, как "бестиповая" переменная, в данном языке программирования вообще не существует. Более того, тип значения определяет те операции, которые разрешается выполнять над ним. Операция, разрешенная для одного типа данных, может оказаться не-. допустимой для другого.

ПРИМЕЧАНИЕ

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

Типы значений в C#

В C# имеются две общие категории встроенных типов данных: типы значений и ссылочные типы. Они отличаются по содержимому переменной. Если переменная относится к типу значения, то она содержит само значение, например 3,1416 или 212. А если переменная относится к ссылочному типу, то она содержит ссылку на значение. Наиболее распространенным примером использования ссылочного типа является класс, но о классах и ссылочных типах речь пойдет далее в этой книге. А здесь рассматриваются типы значений.

В основу языка C# положены 13 типов значений, перечисленных в табл. 3.1. Все они называются простыми типами, поскольку состоят из единственного значения. (Иными словами, они не состоят из двух или более значений.) Они составляют основу системы типов С#, предоставляя простейшие, низкоуровневые элементы данных, которыми можно оперировать в программе. Простые типы данных иногда еще называют примитивными.

Таблица. 3.1. Типы значений в C#

Тип

Значение

bool

Логический, предоставляет два значения: “истина” или “ложь”

byte

8-разрядный целочисленный без знака

char

Символьный

decimal

Десятичный (для финансовых расчетов)

double

С плавающей точкой двойной точности

float

С плавающей точкой одинарной точности

int

Целочисленный

long

Длинный целочисленный

sbyte

8-разрядный целочисленный со знаком

short

Короткий целочисленный

uint

Целочисленный без знака

ulong

Длинный целочисленный без знака

ushort

Короткий целочисленный без знака

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

ПРИМЕЧАНИЕ

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

Целочисленные типы

В C# определены девять целочисленных типов: char, byte, sbyte, short, ushort, int, uint, long и ulong. Но тип char применяется, главным образом, для представления символов и поэтому рассматривается далее в этой главе. Остальные восемь целочисленных типов предназначены для числовых расчетов. Ниже представлены их диапазон представления чисел и разрядность в битах.

Тип

Разрядность в битах

Диапазон представления чисел

byte

8

0-255

sbyte

8

-128-127

short

16

-32 768-32 767

ushort

16

0-65 535

int

32

-2 147 483 648-2 147 483 647

uint

32

0-4 294 967 295

long

64

-9 223 372 036 854 775 808-9 223 372 036 854 775 807

ulong

64

0-18 446 744 073 709 551 615

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

Целочисленные типы со знаком имеют большое значение для очень многих алгоритмов, но по абсолютной величине они наполовину меньше своих аналогов без знака. Вот как, например, выглядит число 32 767 типа short в двоичном представлении.

0111111111111111

Если установить старший разряд этого числа равным 1, чтобы получить значение со знаком, то оно будет интерпретировано как -1, принимая во внимание формат дополнения до двух. Но если объявить его как значение типа ushort, то после установки в 1 старшего разряда оно станет равным 65 535.

Вероятно, самым распространенным в программировании целочисленным типом является тип int. Переменные типа int нередко используются для управления циклами, индексирования массивов и математических расчетов общего назначения. Когда же требуется целочисленное значение с большим диапазоном представления чисел, чем у типа int, то для этой цели имеется целый ряд других целочисленных типов. Так, если значение нужно сохранить без знака, то для него можно выбрать тип uint, для больших значений со знаком — тип long, а для больших значений без знака — тип ulong. В качестве примера ниже приведена программа, вычисляющая расстояние от Земли до Солнца в дюймах. Для хранения столь большого значения в ней используется переменная типа long.

// Вычислить расстояние от Земли до Солнца в дюймах.

using System;

class Inches {

static void Main() { long inches; long miles;

miles = 93000000; // 93 000 000 миль до Солнца

// 5 280 футов в миле, 12 дюймов в футе, inches = miles * 5280 * 12;

Console.WriteLine("Расстояние до Солнца: " + inches + " дюймов.");

}

}

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

Расстояние до Солнца: 58 92480000000 дюймов.

Очевидно, что этот результат нельзя было бы сохранить в переменной типа int или uint.

Самыми мелкими целочисленными типами являются byte и sbyte. Тип byte представляет целые значения без знака в пределах от 0 до 255. Переменные типа byte особенно удобны для обработки исходных двоичных данных, например байтового потока, поступающего от некоторого устройства. А для представления мелких целых значений со знаком служит тип sbyte. Ниже приведен пример программы, в которой переменная типа byte используется для управления циклом, где суммируются числа от 1 до 100.

// Использовать тип byte.

using System;

class Use_byte {

static void Main() { byte x; int sum;

sum = 0;

for(x = 1; x <= 100; x++) sum = sum + x;

Console.WriteLine("Сумма чисел от 1 до 100 равна " + sum);

}

}

Результат выполнения этой программы выглядит следующим образом.

Сумма чисел от 1 до 100 равна 5050

В приведенном выше примере программы цикл выполняется только от 1 до 100, что не превышает диапазон представления чисел для типа byte, и поэтому для управления этим циклом не требуется переменная более крупного типа.

Если же требуется целое значение, большее, чем значение типа byte или sbyte, но меньшее, чем значение типа int или uint, то для него можно выбрать тип short или ushort.

Типы для представления чисел с плавающей точкой

Типы с плавающей точкой позволяют представлять числа с дробной частью. В C# имеются две разновидности типов данных с плавающей точкой: float и double. Они представляют числовые значения с одинарной и двойной точностью соответственно. Так, разрядность типа float составляет 32 бита, что приближенно соответствует диапазону представления чисел от 5Е-45 до 3,4Е+38. А разрядность типа double составляет 64 бита, что приближенно соответствует диапазону представления чисел от 5Е-324 до

1,7Е+308.

В программировании на C# чаще применяется тип double, в частности, потому, что во многих математических функциях из библиотеки классов С#, которая одновременно является библиотекой классов для среды .NET Framework, используются числовые значения типа double. Например, метод Sqrt (), определенный в библиотеке классов System. Math, возвращает значение типа double, которое представляет собой квадратный корень из аргумента типа double, передаваемого данному методу. В приведенном ниже примере программы метод Sqrt () используется для вычисления радиуса окружности по площади круга.

// Определить радиус окружности по площади круга.

using System;

class FindRadius { static void Main() {

Double r;

Double area;

area = 10.0;

r = Math.Sqrt(area / 3.1416);

Результат выполнения этой программы выглядит следующим образом.

Радиус равен 1.78412203012729

В приведенном выше примере программы следует обратить внимание на вызов метода Sqrt (). Как упоминалось выше, метод Sqrt () относится к классу Math, поэтому в его*вызове имя Math предшествует имени самого метода. Аналогичным образом имя класса Console предшествует имени метода WriteLine () в его вызове. При вызове некоторых, хотя и не всех, стандартных методов обычно указывается имя их класса, как показано в следующем примере.

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

// Продемонстрировать применение тригонометрических функций.

using System;

class Trigonometry { static void Main() {

Double theta; // угол в радианах    „

for(theta = 0.1; theta <= 1.0;

theta = theta +0.1)    {

Console.WriteLine("Синус угла " + theta +

" i равен " + Math.Sin(theta));

Console.WriteLine("Косинус угла " + theta +

" равен " + Math.Cos(theta));

Console.WriteLine("Тангенс угла " + theta +

" равен " + Math.Tan(theta));

Console.WriteLine ();

}

}

}

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

Синус угла 0.1 равен 0.0998334166468282 Косинус угла 0.1 равен 0.995004165278026 Тангенс угла 0.1 равен 0.100334672085451

Синус угла 0.2 равен 0.198 6693307 95061 Косинус угла 0.2 равен 0.980066577841242 Тангенс угла 0.2 равен 0.202710035508673

Синус угла 0.3 равен 0.2 9552020666134 Косинус угла 0.3 равен 0.955336489125606 Тангенс угла 0.3 равен 0.309336249609623

Для вычисления синуса, косинуса и тангенса угла в приведенном выше примере были использованы стандартные методы Math. Sin (), Math. Cos () и Math. Tan (). Как и метод Math. Sqrt (), эти тригонометрические методы вызываются с аргументом типа double и возвращают результат того же типа. Вычисляемые углы должны быть указаны в радианах.

Десятичный тип данных

Вероятно, самым интересным среди всех числовых типов данных в C# является тип decimal, который предназначен для применения в финансовых расчетах. Этот тип имеет разрядность 128 бит для представления числовых значений в пределах от 1Е-28 до 7,9Е+28. Вам, вероятно, известно, что для обычных арифметических вычислений с плавающей точкой характерны ошибки округления десятичных значений. Эти ошибки исключаются при использовании типа decimal, который позволяет представить числа с точностью до 28 (а иногда и 29) десятичных разрядов. Благодаря тому что этот тип данных способен представлять десятичные значения без ошибок округления, он особенно удобен для расчетов, связанных с финансами.

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

// Использовать тип decimal для расчета скидки.

using System;

class UseDecimal { static void Main() { decimal price; decimal discount; decimal discounted_price;

// Рассчитать цену со скидкой, price = 19.95m;

discount = 0.15m; // норма скидки составляет 15% discounted_price = price - ( price * discount);

Console.WriteLine("Цена со скидкой: $" + discounted_price);

}

}

Результат выполнения этой программы выглядит следующим образом.

Цена со скидкой: $16.9575

Обратите внимание на то, что значения констант типа decimal в приведенном выше примере программы указываются с суффиксом т. Дело в том, что без суффикса m эти значения интерпретировались бы как стандартные константы с плавающей точкой, которые несовместимы с типом данных decimal. Тем не менее переменной типа decimal можно присвоить целое значение без суффикса т, например 10. (Подробнее

о числовых константах речь пойдет далее в этой‘главе.)

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

/*

Применить тип decimal для расчета будущей стоимости капиталовложений.

*/

using System;

class FutVal {

static void Main() { decimal amount; decimal rate_of_return; int years, i;

amount = 1000.0M; rate_of_return = 0.07M; years = 10;

Console.WriteLine("Первоначальные капиталовложения: $" + amount);

Console.WriteLine("Норма прибыли: " + rate_of_return);

Console.WriteLine("В течение " + years + " лет");

for(i =0; i < years; i++)

amount = amount + (amount * rate_of_return);

Console.WriteLine("Будущая стоимость равна $" + amount);

}

}

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

Первоначальные капиталовложения: $1000 Норма прибыли: 0.07 В течение 10 лет

Будущая стоимость равна $1967.151357289565322490000

Обратите внимание на то, что результат выполнения приведенной выше программы представлен с точностью ДО целого ряда десятичных разрядов, т.е. с явным избытком по сравнению с тем, что обычно требуется! Далее в этой главе будет показано, как подобный результат приводится к более "привлекательному" виду.

Символы

В C# символы представлены не 8-разрядным кодом, как во многих других языках программирования, например C++, а 16-разрядным кодом, который называется уникодом (Unicode). В уникоде набор символов представлен настолько широко, что он охватывает символы практически из всех естественных языков на свете. Если для многих естественных языков, в том числе английского, французского и немецкого, характерны относительно небольшие алфавиты, то в ряде других языков, например китайском, употребляются довольно обширные наборы символов, которые нельзя представить 8-разрядным кодом. Для преодоления этого ограничения в C# определен тип char, представляющий 16-разрядные значения без знака в пределах от 0 до 65 535. При этом стандартный набор символов в 8-разрядном коде ASCII является подмножеством уникода в пределах от 0 до 127. Следовательно, символы в коде ASCII по-прежнему остаются действительными в С#.

Для того чтобы присвоить значение символьной переменной, достаточно заключить это значение (т.е. символ) в одинарные кавычки. Так, в приведенном ниже фрагменте кода переменной ch присваивается символ X.

char ch; ch = 'X';

Значение типа char можно вывести на экран с помощью метода WriteLine (). Например, в следующей строке кода на экран выводится значение переменной ch.

Console'.WriteLine ("Значение ch равно: " + ch) ;

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

char ch;

ch = 88; // ошибка, не выйдет

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

Логический тип данных

Тип bool представляет два логических значения: "истина" и "ложь". Эти логические значения обозначаются в C# зарезервированными словами true и false соответственно. Следовательно, переменная или выражение типа bool будет принимать одно из этих логических значений. Кроме того, в C# не определено взаимное преобразование логических и целых значений. Например, 1 не преобразуется в значение true, а 0 — в значение false.

В приведенном ниже примере программы демонстрируется применение типа bool.

// Продемонстрировать применение типа bool.

using System;

class BoolDemo {

static void Main() { bool b; b = false;

Console.WriteLine("b равно " + b); b = true;

Console.WriteLine("b равно " + b);

// Логическое значение может управлять оператором if. if(b) Console.WriteLine("Выполняется.");

b = false;

if(b) Console.WriteLine("He выполняется.");

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

Console.WriteLine("10 > 9 равно " + (10 > 9));

}

}

Эта программа дает следующий результат.

b равно False b равно True Выполняется.

10 > 9 равно True

В приведенной выше программе обнаруживаются три интересные особенности. Во-первых, при выводе логического значения тийа bool с помощью метода WriteLineO на экране появляется значение 'True" или "False". Во-вторых, самого значения переменной типа bool достаточно для управления оператором if. Для этого не нужно, например, записывать оператор if следующим образом.

if(b == true) . . .

И в-третьих, результатом выполнения оператора отношения является логическое значение. Именно поэтому в результате вычисления выражения 10 > 9 на экран выводится значение "True." Кроме того, выражение 10 > 9 следует заключить в скобки, поскольку оператор + имеет более высокий приоритет, чем оператор >.

Некоторые возможности вывода

До сих пор при выводе с помощью метода WriteLineO данные отображались в формате, используемом по умолчанию. Но в среде .NET Framework определен достаточно развитый механизм форматирования, позволяющий во всех деталях управлять выводом данных. Форматированный ввод-вывод подробнее рассматривается далее в этой книге, а до тех пор полезно ознакомиться с некоторыми возможностями форматирования. Они позволяют указать, в каком именно виде следует выводить значения с помощью метода WriteLine (). Благодаря этому выводимый результат выглядит более привлекательно. Следует, однако, иметь в виду, что механизм форматирования поддерживает намного больше возможностей, а не только те, которые рассматриваются в этом разделе.

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

Console.WriteLine("Вы заказали " + 2 +

" предмета по цене $" + 3 + " каждый.");

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

Console.WriteLine("Деление 10/3 дает: " + 10.0/3.0); который выводит следующий результат.

Деление 10/3 дает: 3.33333333333333

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

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

WriteLine("форматирующая строка", argO, argl, ... , argN);

В этой форме аргументы метода WriteLine () разделяются запятой, а не знаком +. А форматирующая строка состоит из двух элементов: обычных печатаемых символов, предназначенных для вывода в исходном виде, а также спецификаторов формата. Последние указываются в следующей общей форме:

{argnum, width: fmt}

где argnum — номер выводимого аргумента, начиная с нуля; width — минимальная ширина поля; fmt — формат. Параметры width и fmt являются необязательными.

Если во время выполнения в форматирующей строке встречается спецификатор формата, то вместо него подставляется и отображается соответствующий аргумент, обозначаемый параметром argnum. Таким образом, местоположение спецификатора формата в форматирующей строке определяет место отображения соответствующих данных. Параметры width и fmt'указывать необязательно. Это означает, что в своей простейшей форме спецификатор формата обозначает конкретный отображаемый аргумент. Например, спецификатор { 0 } обозначает аргумент агдО, спецификатор {1} — аргумент argl и т.д.

Начнем с самого простого примера. При выполнение оператора

Console.WriteLine("В феврале {0} или {1} дней.", 28, 29);

получается следующий результат.

В феврале 28 или 2 9 дней

Как видите, значение 2 8 подставляется вместо спецификатора { 0 }, а значение 2 9 — вместо спецификатора {1}. Следовательно, спецификаторы формата обозначают место в строке, где отображаются соответствующие аргументы (в данном случае — значения 28 и 2 9). Кроме того, обратите внимание на то, что дополнительные значения разделяются запятой, а не знаком +.

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

Console.WriteLine("В феврале {0,10} или {1,5} дней.", 28, 29);

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

В феврале    28    или    2    9    дней.

Как видите, неиспользуемые части полей заполнены пробелами. Напомним, что минимальная ширина поля определяется параметром width. Если требуется, она может быть превышена при выводе результата.

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

// Применить команды форматирования.

using System;

class DisplayOptions { static void Main() { int i;

Console .WriteLine ("Число^Квадрат^Куб") ;

for(i = 1; i < 10; i++)

Console.WriteLine("{0}\t{1}\t{2}", i, i*i, i*i*i);

}

}

Результат выполнения этой программы выглядит следующим образом.

Число Квадрат Куб f

1

1

1

2

4

8

3

9

27

4

16

64

5

25

125

6

36

216

7

49

343

8

64

512

9

81

729

В приведенных выше примерах сами выводимые значения не форматировались. Но ведь основное назначение спецификаторов формата — управлять внешним видом выводимых данных. Чаще всего форматированию подлежат следующие типы данных: с плавающей точкой и десятичный. Самый простой способ указать формат данных — описать шаблон, который будет использоваться в методе WriteLine(). Для этого указывается образец требуемого формата с помощью символов #, обозначающих разряды чисел. Кроме того, можно указать десятичную точку и запятые, разделяющие цифры. Ниже приведен пример более подходящего вывода результата деления 10 на 3.

Console.WriteLine("Деление 10/3 дает: {0:#.##}", 10.0/3.0);

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

Деление 10/3 дает: 3.33

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

Рассмотрим еще один пример. Оператор

Console.WriteLine("{0:###,###.##}", 123456.56) ; дает следующий результат.

123,456.56

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

decimal balance; balance = 12323.09m;

Console.WriteLine("Текущий баланс равен {0:C}", balance);

Результат выполнения этого фрагмента кода выводится в формате денежных сумм, указываемых в долларах США.

Текущий баланс равен $12,323.0 9

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

// Использовать спецификатор формата С для вывода // результата в местной валюте.

using System;

class UseDecimal { static void Main() { decimal price; decimal discount; decimal discounted_price;

// рассчитать цену со скидкой, price = 19.95m;

discount = 0.15m; // норма скидки составляет 15% discounted_price = price - ( price * discount);

Console.WriteLine("Цена со скидкой: {0:C}", discounted_price);

}

}

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

Цена со скидкой: 16,96 грн.

Литералы

В C# литералами называются постоянные значения, представленные в удобной для восприятия форме. Например, число 100 является литералом. Сами литералы и их назначение настолько понятны, что они применялись во всех предыдущих примерах программ без всяких пояснений. Но теперь настало время дать им формальное объяснение.

В C# литералы могут быть любого простого типа. Представление каждого литерала зависит от конкретного типа. Как пояснялось ранее, символьные литералы заключаются в одинарные кавычки. Например, 1 а1 и 1 % 1 являются символьными литералами.

Целочисленные литералы указываются в виде чисел без дробной части. Например, 10 и -100 — это целочисленные литералы. Для обозначения литералов с плавающей точкой требуется указывать десятичную точку и дробную часть числа. Например,

11.123 — это литерал с плавающей точкой. Для вещественных чисел с плавающей точкой в C# допускается также использовать экспоненциальное представление.

У литералов должен быть также конкретный тип, поскольку C# является строго типизированным языком. В этой связи возникает естественный вопрос: к какому типу следует отнести числовой литерал, например 2, 123987 или 0 . 23? К счастью, для ответа на этот вопрос в C# установлен ряд простых для соблюдения правил.

Во-первых, у целочисленных литералов должен быть самый мелкий целочисленный тип, которым они могут быть представлены, начиная с типа int. Таким образом, у целочисленных литералов может быть один из следующих типов: int, uint, long или ulong в зависимости от значения литерала. И во-вторых, литералы с плавающей точкой относятся к типу double.

Если вас не устраивает используемый по умолчанию тип литерала, вы можете ярно указать другой его тип с помощью суффикса. Так, для указания типа long к литералу присоединяется суффикс 1 или L. Например, 12 — это литерал типа int, al2L — литерал типа long. Для указания целочисленного типа без знака к литералу присоединяется суффикс и или U. Следовательно, 100 — это литерал типа int, a 100U — литерал типа uint. А для указания длинного целочисленного типа без знака к литералу присоединяется суффикс ul или UL. Например, 984375UL — это литерал типа ulong.

Кроме того, для указания типа float к литералу присоединяется суффикс F или f. Например, 10 .19F — это литерал типа float. Можете даже указать тип double, присоединив к литералу суффикс d или D, хотя это излишне. Ведь, как упоминалось выше, по умолчанию литералы с плавающей точкой относятся к типу double.

И наконец, для указания типа decimal к литералу присоединяется суффикс m или М. Например, 9 . 95М — это десятичный литерал типа decimal.

Несмотря на то что целочисленные литералы образуют по умолчанию значения типа int, uint, long или ulong, их можно присваивать переменным типа byte, sbyte, short или ushort, при условии, что присваиваемое значение может быть представлено целевым типом.

Шестнадцатеричные литералы

Вам, вероятно, известно, что в программировании иногда оказывается проще пользоваться системой счисления по основанию 16, чем по основанию 10. Система счисления по основанию 16 называется шестнадцатеричной. В ней используются числа от 0 до 9, а также буквы от А до F, которыми обозначаются десятичные числа 10,11,12,13, 14 и 15. Например, десятичному числу 16 соответствует шестнадцатеричное число 10. Вследствие того что шестнадцатеричные числа применяются в программировании довольно часто, в C# разрешается указывать целочисленные литералы в шестнадцатеричном формате. Шестнадцатеричные литералы должны начинаться с символов Ох, т.е. нуля и последующей латинской буквы "икс". Ниже приведены некоторые примеры шестнадцатеричных литералов.

count = OxFF; // 255 в десятичной системе incr = 0x1а;    //    26 в десятичной системе

Управляющие последовательности символов

Большинство печатаемых символов достаточно заключить в одинарные кавычки, но набор в текстовом редакторе некоторых символов, например возврата каретки, вызывает особые трудности. Кроме того, ряд других символов, в том числе одинарные и двойные кавычки, имеют специальное назначение в С#, поэтому их нельзя использовать непосредственно. По этим причинам в C# предусмотрены специальные управляющие последовательности символов, иногда еще называемые константами с обратной косой чертой (табл. 3.2). Такие последовательности применяются вместо тех символов, которых они представляют.'

Таблица 3.2. Управляющие последовательности символов

Управляющая последовательность

Описание

\a

Звуковой сигнал (звонок)

\b

Возврат на одну позицию

\f

Перевод страницы (переход на новую страницу)

\n

Новая строка (перевод строки)

\r

Возврат каретки

\t

Горизонтальная табуляция

\v

Вертикальная табуляция

\0

Пустой символ

V

Одинарная кавычка

\"

Двойная кавычка

w

Обратная косая черта

Например, в следующей строке кода переменной ch присваивается символ табуляции.

ch = 1\t1;

А в приведенном ниже примере кода переменной ch присваивается символ одинарной кавычки.

ch = 1 \ ' ';

Строковые литералы

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

"это тест"

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

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

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

.using System;

class StrDemo {

static void Main() {

Console.WriteLine("Первая строка\пВторая строка\пТретья строка");

Console.WriteLine("OflHH\tflBa\tTpn");

Console.WriteLine("Четыре^Пять\Шесть" ) ;

// Вставить кавычки.

Console.WriteLine("\"3ачем?\", спросил он.");

}

}

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

Первая строка Вторая строка Третья строка Один    Два    Три

Четыре Пять    Шесть

"Зачем?", спросил он.

В приведенном выше примере программы обратите внимание на то, что для перехода на новую строку используется управляющая последовательность \п. Для вывода нескольких строк совсем не обязательно вызывать метод WriteLine () несколько раз — достаточно вставить управляющую последовательность \п в тех местах удлиненной текстовой строки (или строкового литерала), где должен происходить переход на новую строку. Обратите также внимание на то, как в текстовой строке формируется знак кавычек.

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

// Продемонстрировать применение буквальных строковых литералов, using System;

class Verbatim {    ,

static void Main() {

Console.WriteLine(@"Это буквальный строковый литерал, занимающий несколько строк.

") ;

Console.WriteLine(@"А это вывод с табуляцией:

12    3    4

5    6    7    8

м) ;

Console.WriteLine(@"Отзыв программиста: ""Мне нравится С#."");

Это буквальный строковый литерал, занимающий несколько строк.

А это вывод с-табуляцией:

1    ‘2    3    4

5    6    7    8

Отзыв программиста: "Мне нравится С#."

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

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

И последнее замечание: не путайте строки с символами. Символьный литерал, например 1X1, обозначает одиночную букву типа char. А строка, состоящая из одного символа, например "X", по-прежнему остается текстовой строкой.

Более подробное рассмотрение переменных

Переменные объявляются с помощью оператора следующей формы:

тип имя_переменной;

где тип — это тип данных, хранящихся в переменной; а имя_переменной — это ее имя. Объявить можно переменную любого действительного типа, в том числе и описанных выше типов значений. Важно подчеркнуть, что возможности переменной определяются ее типом. Например, переменную типа bool нельзя использовать для хранения числовых значений с плавающей точкой. Кроме того, тип переменной нельзя изменять в течение срока ее существования. В частности, переменную типа int нельзя преобразовать в переменную типа char.

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

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

Инициализация переменной

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

тип имя_переменной = значение;

где зна чение — это конкретное значение, задаваемое при создании переменной. Оно должно соответствовать указанному типу переменной.

Ниже приведены некоторые примеры инициализации переменных.

int count = 10;    //    задать начальное значение 10 переменной count.

char ch = 'X';    // инициализировать переменную ch буквенным значением X.

float f = 1.2F    //    переменная    f    инициализируется    числовым    значением 1,2.

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

int a, b=8, с=19, d; // инициализировать переменные b и с

В данном примере инициализируются только переменные b и с.

Динамическая инициализация

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

// Продемонстрировать динамическую инициализацию.

using System;

class Dynlnit {

static void Main() {

// Длина сторон прямоугольного треугольника. double si = 4.0; double s2 = 5.0;

// Инициализировать переменную hypot динамически, double hypot = Math.Sqrt( (si * si) + (s2 * s2) );

Console.Write("Гипотенуза треугольника со сторонами " + si + " и " + s2 + " равна ");

Console.WriteLine("{0:#.###}.", hypot);

}

}

Результат выполнения этой программы выглядит следующим образом.

Гипотенуза треугольника со сторонами 4 и 5 равна 6.403

В данном примере объявляются три локальные переменные: si, s2 и hypot. Две из них (si и s2) инициализируются константами, А третья (hypot) динамически инициализируется вычисляемой длиной гипотенузы. Для такой инициализации используется выражение, указываемое в вызываемом методе Math. Sqrt (). Как пояснялось выше, для динамической инициализации пригодно любое выражение, действительное на момент объявления переменной. А поскольку вызов метода Math. Sqrt () (или любого другого библиотечного метода) является действительным на данный момент, то его можно использовать для инициализации переменной hypot. Следует особо подчеркнуть, что в выражении для инициализации можно использовать любой элемент, действительный на момент самой инициализации переменной, в том числе вызовы методов, другие переменные или литералы.

Неявно типизированные переменные

Как пояснялось выше, все переменные в C# должны быть объявлены. Как правило, при объявлении переменной сначала указывается тип, например int или bool, а затем имя переменной. Но начиная с версии C# 3.0, компилятору предоставляется возможность самому определить тип локальной переменной, исходя из значения, которым она инициализируется. Такая переменная называется неявно типизированной.

Неявно типизированная переменная объявляется с помощью ключевого слова var и должна быть непременно инициализирована. Для определения типа этой переменной компилятору служит тип ее инициализатора, т.е. значения, которым она инициализируется. Рассмотрим такой пример.

var е = 2.7183;

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

var е = 2.7183F;

то она была бы отнесена к типу float.

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

// Продемонстрировать применение неявно типизированных переменных, using System;

class ImplicitlyTypedVar { static void Main() {

// Эти переменные типизированы неявно. Они отнесены // к типу double, поскольку инициализирующие их // выражения сами относятся к типу double, var si = 4.0; var s2 = 5.0;

// Итак, переменная hypot типизирована неявно и // относится к типу double, поскольку результат,

// возвращаемый методом Sqrt(), имеет тип double, var hypot = Math.Sqrt( (si * si) + (s2 * s2)    );

Console.Write("Гипотенуза треугольника со сторонами " + si + " by " + s2 + " равна ");

Console.WriteLine("{0:#.###}.", hypot);

// Следующий оператор не может быть скомпилирован,

// поскольку переменная si имеет тип double и // ей нельзя присвоить десятичное значение.

// si = 12.2М; // Ошибка!

}

}

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

// si = 12.2М; // Ошибка!

Эта операция присваивания недействительна, поскольку переменная s 1 относится к типу double. Следовательно, ей нельзя присвоить десятичное значение. Единственное отличие неявно типизированной переменной от обычной, явно типизированной переменной, — в способе определения ее типа. Как только этот тип будет определен, он закрепляется за переменной до конца ее существования. Это, в частности, означает, что тип переменной s 1 не может быть изменен по ходу выполнения программы.

Неявно типизированные переменные внедрены в C# не для того, чтобы заменить собой обычные объявления переменных. Напротив, неявно типизированные переменные предназначены для особых случаев, и самый примечательный из них имеет отношение к языку интегрированных запросов (LINQ), подробно рассматриваемому в главе 19. Таким образом, большинство объявлений переменных должно и впредь оставаться явно типизированными, поскольку они облегчают чтение и понимание исходного текста программы.

И последнее замечание: одновременно можно объявить только одну неявно типизированную переменную. Поэтому объявление

var si =4.0, s2=5.0; // Ошибка!

является неверным и не может быть скомпилировано. Ведь в нем предпринимается попытка объявить обе переменные, si и s2, одновременно.

Область действия и время существования переменных

Все переменные, использовавшиеся в предыдущих примерах программ, объявлялись в самом начале метода Main (). Но в C# локальную переменную разрешается объявлять в любом кодовом блоке. Как пояснялось в главе 2, кодовый блок начинается открывающей фигурной скобкой и оканчивается закрывающей фигурной скобкой. Этот блок и определяет область действия. Следовательно, всякий раз, когда начинается блок, образуется новая область действия. Прежде всего область действия определяет видимость имен отдельных элементов, в том числе и переменных, в других частях программы без дополнительного уточнения. Она определяет также время существования локальных переменных.

В C# к числу наиболее важных относятся области действия, определяемые классом и методом. Рассмотрение области действия класса (и объявляемых в ней переменных) придется отложить до того момента, когда в этой книге будут описываться классы. А до тех пор будут рассматриваться только те области действия, которые определяются методом или же в самом методе.

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

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

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

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

// Продемонстрировать область действия кодового блока, using System;

class ScopeDemo {

static void Main() {

int x; // Эта переменная доступна для всего кода внутри метода Main().

х = 10;

if (х == 10)    {    // начать новую область действия

int у = 20; // Эта переменная доступна только в данном кодовом блоке.

// Здесь доступны обе переменные, х и у.

Console.WriteLine("х и у: " + х + " " + у); х = у * 2;

}

// у = 100; // Ошибка! Переменна у здесь недоступна.

//А переменная х здесь по-прежнему доступна.

Console.WriteLine("х равно " + х) ;

}

}

Как поясняется в комментариях к приведенной выше программе, переменная х объявляется в начале области действия метода Main (), и поэтому она доступна для всего последующего кода в пределах этого метода. В блоке условного оператора i f объявляется переменная у. А поскольку этот кодовый блок определяет свою собственную область действия, то переменная у видима только для кода в пределах данного блока. Именно поэтому строка line у = 100 ;, находящаяся за пределами этого блока, закомментирована. Если удалить находящиеся перед ней символы комментария (//), то во время компиляции программы произойдет ошибка, поскольку переменная у невидима за пределами своего кодового блока. В то же время переменная х может использоваться в блоке условного оператора i f, поскольку коду из этого блока, находящемуся во вложенной области действия, доступны переменные, объявленные в охватывающей его внешней области действия.

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

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

// Продемонстрировать время существования переменной.

using System;

class VarlnitDemo { static void Main() { int x;

for(x = 0; x < 3; x++)    {

int у = -1; // Переменная у инициализируется при каждом входе в блок. Console.WriteLine("у равно: " + у); // Здесь всегда выводится -1

у = 100;

Console.WriteLine("у теперь равно: " + у);

}

}

}

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

У

равно:

-1

У

теперь

равно:

100

У

равно:

-1

У

теперь

равно:

100

У

равно:

-1

У

теперь

равно:

100

Как видите, переменная у повторно инициализируется одним и тем же значением -1 при каждом входе во внутренний цикл for. И несмотря на то, что после этого цикла ей присваивается значение 100, оно теряется при повторной ее инициализации.

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

/*

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

*** Эта программа не может быть скомпилирована. ***

*/

using System;

class NestVar {

static void Main() { int count;

for(count = 0; count < 10; count = count+1) {

Console.WriteLine("Это подсчет: " + count);

int count; // Недопустимо!!!

for(count = 0; count < 2; count++)

Console.WriteLine("В этой программе есть ошибка!");

}

}

}

Если у вас имеется некоторый опыт программирования на С или C++, то вам должно быть известно, что на присваивание имен переменным, объявляемым во внутренней области действия, в этих языках не существует никаких ограничений. Следовательно, в С и C++ объявление переменной count в кодовом блоке, входящем во внешний цикл for, как в приведенном выше примере, считается вполне допустимым. Но в С и C++ такое объявление одновременно означает сокрытие внешней переменной. Разработчики C# посчитали, что такого рода сокрытие имен может легко привести к программным ошибкам, и поэтому решили запретить его.

Преобразование и приведение типов

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

int i; float f;

i = 10;

f = i; // присвоить целое значение переменной типа float

Если в одной операции присваивания смешиваются совместимые типы данных, то значение в правой части оператора присваивания автоматически преобразуется в тип, указанный в левой его части. Поэтому в приведенном выше фрагменте кода значение переменной i сначала преобразуется в тип float, а затем присваивается переменной f. Но вследствие строгого контроля типов далеко не все типы данных в C# оказываются полностью совместимыми, а следовательно, не все преобразования типов разрешены в неявном виде. Например, типы bool и int несовместимы. Правда, преобразование несовместимых типов все-таки может быть осуществлено путем приведения. Приведение типов, по существу, означает явное их преобразование. В этом разделе рассматривается как автоматическое преобразование, так и приведение типов.

Автоматическое преобразование типов

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

•    оба типа совместимы;

•    диапазон представления чисел целевого типа шире, чем у исходного типа.

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

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

// Продемонстрировать неявное преобразование типа long в тип double.

using System;

class LtoD {

static void Main() { long L; double D;

L = 100123285L;

D = L;

Console.WriteLine("L и D: " + L + " " + D);

}

}

Если тип long может быть преобразован в тип double неявно, то обратное преобразование типа double в тип long неявным образом невозможно, поскольку оно не является расширяющим. Следовательно, приведенный ниже вариант предыдущей программы составлен неправильно.

// *** Эта программа не может быть скомпилирована. ***

using System;

/

class LtoD {

static void Main() { long L; double D;

D = 100123285.0;

L = D; // Недопустимо!!!

Console.WriteLine("L и D:■ " + L + " " + D);

}

}

Помимо упомянутых выше ограничений, не допускается неявное взаимное преобразование типов decimal и float или double, а также числовых типов и char или bool. Кроме того, типы char и bool несовместимы друг с другом.

Приведение несовместимых типов

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

(целевой_тип) выражение

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

double х, у;

Если результат вычисления выражения х/у должен быть типа int, то следует записать следующее.

(int) (х / у)

Несмотря на то что переменные х и у относятся к типу double, результат вычисления выражения х/у преобразуется в тип int благодаря приведению. В данном примере выражение х/у следует непременно указывать в скобках, иначе приведение к типу int будет распространяться только на переменную х, а не на результат ее деления на переменную у. Приведение типов в данном случае требуется потому, что неявное преобразование типа double в тип int невозможно.

Если приведение типов приводит к сужающему преобразованию, то часть информации может быть потеряна. Например, в результате приведения типа long к типу int часть информации потеряется, если значение типа long окажется больше диапазона представления чисел для типа int, поскольку старшие разряды этого числового значения отбрасываются. Когда же значение с плавающей точкой приводится к целочисленному, то в результате усечения теряется дробная часть этого числового значения. Так, если присвоить значение 1,23 целочисленной переменной, то в результате в ней останется лишь целая часть исходного числа (1), а дробная его часть (0,23) будет потеряна.

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

// Продемонстрировать приведение типов.

using System;

class CastDemo {

static void Main() { double x, y; byte b; int i; char ch; uint u; short s; long 1;

x = 10.0;

У = 3.0;

11 Приведение типа double к типу int, дробная часть числа теряется, i = (int) (х / у) ;

Console.WriteLine("Целочисленный результат деления х / у: " + i) ; Console.WriteLine();

// Приведение типа int к типу byte без потери данных, i = 255; b = (byte) i;

Console.WriteLine("b после присваивания 255: " + b +

" -- без потери данных.");

// Приведение типа int к типу byte с потерей данных, i = 257; b = (byte) i;

Console.WriteLine("b после присваивания 257: " + b +

" — с потерей данных.");

Console.WriteLine();

// Приведение типа uint к типу short без потери данных, и = 32000; s = (short) u;

Console.WriteLine("s после присваивания 32000: " + s + " — без потери данных.");

// Приведение типа uint к типу short с потерей данных, и = 64000; s = (short) u;

Console.WriteLine("s после присваивания 64000: " + s + " — с потерей данных. ") ;

Console.WriteLine();

// Приведение типа long к типу uint без потери данных.

1 = 64000; u = (uint) 1;

Console.WriteLine("и после присваивания 64000: " + u +

" -- без потери данных.");

// Приведение типа long к типу uint с потерей данных.

1 = -12; u = (uint) 1;

Console.WriteLine("и после присваивания -12: " + u +

" — с потерей данных.");

Console.WriteLine();

// Приведение типа int к типу char, b = 88; // код ASCII символа X ch = (char) b;

Console.WriteLine("ch после присваивания 88: " + ch);

}

}

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

Целочисленный результат деления х / у: 3

b после присваивания 255: 255 -- без потери данных.

Ь после присваивания 257: 1 — с потерей данных.i

s после    присваивания    32000:    32000    --    без потери данных,

s после    присваивания    64000:    -1536    --    с потерей данных.

и после-присваивания    64000:    64000    —    без потери данных,

и после    присваивания    -12: 4294967284    -- с потерей данных.

ch после присваивания 88: X

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

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

Когда переменной s типа short присваивается значение 32 000 переменной и типа uint, потери данных не происходит, поскольку это значение входит в диапазон представления чисел для типа short. Но в следующей операции присваивания переменная и имеет значение 64 000, которое оказывается вне диапазона представления чисел для типа short, и поэтому данные теряются. Приведение типов требуется в обоих случаях, поскольку неявное преобразование типа uint в тип short невозможно.

Далее переменной и присваивается значение 64 000 переменной 1 типа long. В этом случае данные не теряются, поскольку значение 64 000 оказывается вне диапазона представления чисел для типа uint. Но когда переменной и присваивается значение -12, данные теряются, поскольку отрицательные числа также оказываются вне диапазона представления чисел для типа uint. Приведение типов требуется в обоих случаях, так как неявное преобразование типа long в тип uint невозможно.

И наконец, когда переменной char присваивается значение типа byte, информация не теряется, но приведение типов все же требуется.

Преобразование типов в выражениях

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

Преобразования типов выполняются по принятым в C# правилам продвижения типов. Ниже приведен алгоритм, определяемый этими правилами для операций с двумя операндами.

ЕСЛИ один операнд имеет тип decimal, ТО и второй операнд продвигается к типу decimal (но если второй операнд имеет тип float или double, результат будет ошибочным).

ЕСЛИ один операнд имеет тип double, ТО и второй операнд продвигается к типу double.

ЕСЛИ один операнд имеет тип float, ТО и второй операнд продвигается к типу float.

ЕСЛИ один операнд имеет тип ulong, ТО и второй операнд продвигается к типу ulong (но если второй операнд имеет тип sbyte, short, int или long, результат будет ошибочным).

ЕСЛИ один операнд имеет тип long, ТО и второй операнд продвигается к типу long.

ЕСЛИ один операнд имеет тип uint, а второй — тип sbyte, short или int, ТО оба операнда продвигаются к типу long.

ЕСЛИ один операнд имеет тип uint, ТО и второй операнд продвигается к типу uint.

ИНАЧЕ оба операнда продвигаются к типу int.

Относительно правил продвижения типов необходимо сделать ряд важных замечаний. Во-первых, не все типы могут смешиваться в выражении. В частности, неявное преобразование типа float или double в тип decimal невозможно, как, впрочем, и смешение типа ulong с любым целочисленным типом со знаком. Для смешения этих типов требуется явное их приведение.

Во-вторых, особого внимания требует последнее из приведенных выше правил. Оно гласит: если ни одно из предыдущих правил не применяется, то все операнды продвигаются к типу int. Следовательно, все значения типа char, sbyte, byte, ushort и short продвигаются к типу int в целях вычисления выражения. Такое продвижение типов называется целочисленным. Это также означает, что результат выполнения всех арифметических операций будет иметь тип не ниже int.

Следует иметь в виду, что правила продвижения типов применяются только к значениям, которыми оперируют при вычислении выражения. Так, если значение переменной типа byte продвигается к типу int внутри выражения, то вне выражения эта переменная по-прежнему относится к типу byte. Продвижение типов затрагивает только вычисление выражения.

Но продвижение типов может иногда привести к неожиданным результатам. Если, например, в арифметической операции используются два значения типа byte, то происходит следующее. Сначала операнды типа byte продвигаются к типу int. А затем выполняется операция, дающая результат типа int. Следовательно, результат выполнения операции, в которой участвуют два значения типа byte, будет иметь тип int. Но ведь это не тот результат, который можно было бы с очевидностью предположить. Рассмотрим следующий пример программы.

// Пример неожиданного результата продвижения типов!

using System;

class PromDemo {

static void Main() { byte b;

b = 10;

b = (byte) (b * Ь); // Необходимо приведение типов!!

Console.WriteLine("b: "+ b);

}

}

Как ни странно, но когда результат вычисления выражения b*b присваивается обратно переменной Ь, то возникает потребность в приведении к типу byte! Объясняется это тем, что в выражении b*b значение переменной b продвигается к типу int и поэтому не может быть присвоено переменной типа byte без приведения типов. Имейте это обстоятельство в виду, если получите неожиданное сообщение об ошибке несовместимости типов в выражениях, которые, на первый взгляд, кажутся совершенно правильными.

Аналогичная ситуация возникает при выполнении операций с символьными операндами. Например, в следующем фрагменте кода требуется обратное приведение к типу char, поскольку операнды chi и ch2 в выражении продвигаются к типу int.

char chi = 'a', ch2 = 'b1;

chi = (char) (chi•+ ch2);

Без приведения типов результат сложения операндов chi и ch2 будет иметь тип int, и поэтому его нельзя присвоить переменной типа char.

Продвижение типов происходит и при выполнении унарных операций, например с унарным минусом. Операнды унарных операций более мелкого типа, чем int (byte, sbyte, short и ushort), т.е. с более узким диапазоном представления чисел, продвигаются к типу int. То же самое происходит и с операндом типа char. Кроме того, если выполняется унарная операция отрицания значения типа uint, то результат продвигается к типу long.

Приведение типов в выражениях

Приведение типов можно применять и к отдельным частям крупного выражения. Это позволяет точнее управлять преобразованиями типов при вычислении выражения. Рассмотрим следующий пример программы, в которой выводятся квадратные корни чисел от 1 до 10 и отдельно целые и дробные части каждого числового результата. Для этого в данной программе применяется приведение типов, благодаря которому результат, возвращаемый методом Math. Sqrt (), преобразуется в тип int.

// Пример приведения типов в выражениях.

using System;

class CastExpr {

static void Main() { double n;

Console.WriteLine ();

}

}

}

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

Квадратный корень из

1

равен 1

Целая часть числа: 1

Дробная часть числа:

0

Квадратный корень из

2

равен 1.4142135623731

Целая часть числа: 1

Дробная часть числа:

0

.414213562373095

Квадратный корень из

3

равен 1.73205080756888

Целая часть числа: 1

Дробная часть числа:

0

.732050807568877

Квадратный корень из

4

равен 2

Целая часть числа: 2

Дробная часть числа:

0

Квадратный корень из

5

равен 2.23606797749979

Целая часть числа: 2

Дробная часть числа:

0

.23606797749979

Квадратный корень из

6

равен 2.44948974278318

Целая ч^сть числа: 2

Дробная часть числа:

0

.449489742783178

Квадратный корень из

7

равен 2.64575131106459

Целая часть числа: 2

Дробная часть числа:

0

.645751311064591

Квадратный корень из

8

равен 2.82842712474619

Целая часть числа: 2

Дробная часть числа:

0

.82842712474619

Квадратный корень из

9

равен 3

Целая часть числа: 3

Др'обная часть числа:

0

Квадратный корень из

10 равен 3.16227766016838

Целая часть числа: 3

Дробная часть числа:

0

.16227766016838

Как видите, приведение результата, возвращаемого методом Math. Sqrt (), к типу int позволяет получить целую часть числа. Так, в выражении

Math.Sqrt(n) - (int) Math.Sqrt(n)

приведение к типу int дает целую часть числа, которая затем вычитается из всего числа, а в итоге получается дробная его часть. Следовательно, результат вычисления данного выражения имеет тип double. Но к типу int приводится только значение, возвращаемое вторым методом Math. Sqrt ().

ГЛАВА 4 Операторы

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

Арифметические операторы

Арифметические операторы, представленные в языке С#, приведены ниже.

Оператор

Действие

+

Сложение

-

Вычитание, унарный минус

*

Умножение

/

Деление

о.

Деление по модулю

Декремент

++

Инкремент

Операторы +,    *    и / действуют так, как предполагает их обозначение. Их можно

применять к любому встроенному числовому типу данных.

Действие арифметических операторов не требует особых пояснений, за исключением следующих особых случаев. Прежде всего, не следует забывать, что когда оператор / применяется к целому числу, то любой остаток от деления отбрасывается; например, результат целочисленного деления 10/3 будет равен 3. Остаток от этого деления можно получить с помощью оператора деления по модулю (%), который иначе называется оператором вычисления остатка. Он дает остаток от целочисленного деления. Например, 10 % 3 равно 1. В C# оператор % можно применять как к целочисленным типам данных, так и к типам с плавающей точкой. Поэтому 10.0 % 3.0 также равно 1. В этом отношении C# отличается от языков С и C++, где операции деления по модулю разрешаются только для целочисленных типов данных. В приведенном ниже примере программы демонстрируется применение оператора деления по модулю.

// Продемонстрировать применение оператора %.

using System;

class ModDemo {

static void Main() { int iresult, irem; double dresult, drem;

iresult = 10 / 3; irem = 10 % 3;

dresult = 10.0 / 3.0; drem = 10.0 % 3.0;

Console.WriteLine("Результат и остаток от деления 10/3: " + iresult + " " + irem);

Console.WriteLine("Результат и остаток от деления 10.0 / 3.0: " + dresult + " " + drem);

}

}

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

Результат и остаток от деления 10/3: 3 1

Результат и остаток от деления 10.0 / 3.0: 3.33333333333333 1

Как видите, обе операции, % целочисленного типа и с плавающей точкой, дают один и тот же остаток, равный 1.

Операторы инкремента и декремента

Операторы инкремента (++) и декремента (—) были представлены в главе 2. Как станет ясно в дальнейшем, они обладают рядом особых и довольно интересных свойств. Но сначала выясним основное назначение этих операторов.

Оператор инкремента увеличивает свой операнд на 1, а оператор декремента уменьшает операнд на 1. Следовательно, оператор

х+ + ;

равнозначен оператору х = х + 1; а оператор

х—;

равносилен оператору

х = х - 1;

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

Оба оператора инкремента и декремента можно указывать до операнда (в префиксной форме) или же после операнда (в постфиксной форме). Например, оператор

х = х + 1;

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

++х; // префиксная форма

или же в таком виде:

х++; // постфиксная форма

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

х = 10; у = ++х;

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

X =    10;

у = х++;

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

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

// Продемонстрировать отличие между префиксной // и постфиксной формами оператора инкремента (++).

using System;

class PrePostDemo { static void Main() { int* x, y;

У

int i;

x = 1;

У = 0;

Console.WriteLine("Ряд чисел, полученных    "    +

"с помощью оператора у    =    у    +    х++;"),

for(i =    0; i <    10; i++)    {

у = у    + х++;    // постфиксная форма оператора ++

Console.WriteLine(у + " ");

}

Console.WriteLine();

х = 1; у = 0;

Console.WriteLine("Ряд чисел, полученных    "    +

"с помощью оператора у    =    у    +    ++х;")<

for(i =    0; i <    10; i++)    {

у = у    + ++х;    // префиксная форма оператора ++

Console.WriteLine(у + " ");

}

Console.WriteLine();

}

}

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

Ряд чисел, полученных с помощью оператора у = у + х++

1

3

б

10

15

14

21

28

36

45

55

Ряд чисел, полученных с помощью оператора у = у + ++х;

2

5

9

14

20

27

35

44

54

65    .

Как подтверждает приведенный выше результат, в операторе

у = у + х++;

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

у = у + ++х;

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

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

у + ++Х

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

Операторы отношения и логические операторы

В обозначениях оператор отношения и логический оператор термин отношения означает взаимосвязь, которая может существовать между двумя значениями, а термин логический — взаимосвязь между логическими значениями "истина7' и "ложь". И поскольку операторы отношения дают истинные или ложные результаты, то они нередко применяются вместе с логическими операторами. Именно по этой причине они и рассматриваются совместно в данном разделе.

Ниже перечислены операторы отношения.

Оператор

Значение

==

Равно

I =

Не равно

>

Больше

<

Меньше

>=

Больше или равно

<=

Меньше или равно

К числу логических относятся операторы, приведенные ниже.

Оператор

Значение

&

И

1

ИЛИ

Исключающее ИЛИ

&&

Укороченное И

11

Укороченное ИЛИ

1

НЕ

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

В целом, объекты можно сравнивать на равенство или неравенство, используя операторы отношения == и ! =. А операторы сравнения <, >, <= или >= могут применяться только к тем типам данных, которые поддерживают отношение порядка. Следовательно, операторы отношения можно применять ко всем числовым типам данных. Но значения типа bool могут сравниваться только на равенство или неравенство, поскольку истинные (true) и ложные (false) значения не упорядочиваются. Например, сравне-' ние true > false в C# не имеет смысла.

Операнды логических операторов должны относиться к типу bool, а результат выполнения логической операции также относится к типу bool. Логические операторы &, |, л и ! поддерживают основные логические операции И, ИЛИ, исключающее ИЛИ и НЕ в соответствии с приведенной ниже таблицей истинности.

p

q

p & q

p 1 q

p A q

!p

false

false

false

false

false

true

true

false

false

true

true

false

false

true

false

true

true

true

true

true

true

true

false

false

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

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

// Продемонстрировать применение операторов // отношения и логических операторов.

using System;

class RelLogOps {

static void Main() { int i, j; bool bl, b2;

i = 10; j = 11;

if(i < j) Console.WriteLine("i < j"); if(i <= j) Console.WriteLine("i <= j"); if (i != j) Console.WriteLine("i != j");

if(i == j) Console.WriteLine("Нельзя выполнить"); if(i >= j) Console.WriteLine("Нельзя выполнить"); if(i > j) Console.WriteLine("Нельзя выполнить");

Ы = true7 Ь2 = false;

if(Ы & b2) Console.WriteLine("Нельзя выполнить"); if(!(bl & b2)) Console.WriteLine("!(Ы & Ь2) — true"); if(Ы | b2) Console.WriteLine("bl I b2 - true"); if(Ы A b2) Console.WriteLine("bl A b2 — true");

}

}

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

i < j i <= j i != j

!(bl & b2) — true bl | b2 — true bl A b2 - true

Логические операторы в C# выполняют наиболее распространенные логические операции. Тем не менее существует ряд операций, выполняемых по правилам формальной логики. Эти логические операции могут быть построены с помощью логических операторов, поддерживаемых в С#. Следовательно, в С# предусмотрен такой набор логических операторов, которого достаточно для построения практически любой логической операции, в том числе импликации. Импликация — это двоичная операция, результатом которой является ложное значение только в том случае, если левый ее операнд имеет истинное значение, а правый — ложное. (Операция импликации отражает следующий принцип: истина не может подразумевать ложь.) Ниже приведена таблица истинности для операции импликации.

p

q

Результат импликации p и q

true

true

true

true

false

false

false

false

true

false

true

true

Операция импликации может быть построена на основе комбинации логических операторов ! и |, как в приведенной ниже строке кода.

р I q

В следующем примере программы демонстрируется подобная реализация операции импликации.

// Построение операции импликации в С#.

using System;

class Implication { static void Main() { bool p=false, q=false;

int i, j;

for(i =0; i    <    2;    i++)    {

for(j = 0;    j    <    2; j++)    {

if (i==0)    p    =    true;

if (i==l)    p    =    false;

if (j==0)    q    =    true;

if(j==l) q = false;

Console.WriteLine("p равно " + p + ", q равно " + q);

if ( !p I q)

Console.WriteLine("Результат импликации " + p +

" и " + q + " равен " + true);

Console.WriteLine ();

}

}

}

}

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

р равно True, q равно True

Результат импликации True и True равен True р равно True, q равно False р равно False, q равно False

Результат импликации False и True равен True р равно False, q равно False

Результат импликации False и False равен True

Укороченные логические операторы

В C# предусмотрены также специальные, укороченные, варианты логических операторов И и ИЛИ, предназначенные для получения более эффективного кода. Поясним это на следующих примерах логических операций. Если первый операнд логической операции И имеет ложное значение (false), то ее результат будет иметь ложное значение независимо от значения второго операнда. Если же первый операнд логической операции ИЛИ имеет истинное значение (true), то ее результат будет иметь истинное значение независимо от значения второго операнда. Благодаря тому что значение второго операнда в этих операциях вычислять не нужно, экономится время и повышается эффективность кода.

Укороченная логическая операция И выполняется с помощью оператора &&, а укороченная логическая операция ИЛИ — с помощью оператора | |. Этим укороченным логическим операторам соответствуют обычные логические операторы & и |. Единственное отличие укороченного логического оператора от обычного заключается в том, что второй его операнд вычисляется только по мере необходимости. -

В приведенном ниже примере программы демонстрируется применение укороченного логического оператора И. В этой программе с помощью операции деления по модулю определяется следующее: делится ли значение переменной d на значение переменной п нацело. Если остаток от деления n/d равен нулю, то п делится на d нацело.

Но поскольку данная операция подразумевает деление, то для проверки условия деления на нуль служит укороченный логический оператор И.

// Продемонстрировать применение укороченных логических операторов.

using System;'

class SCops {

static void Main() { int n, d;

n = 10; d = 2;

if(d != 0 && (n % d) == 0)

Console.WriteLine(n + " делится нацело на " + d);

d = 0; // задать нулевое значение переменной d

// d равно нулю, поэтому второй операнд не вычисляется if(d != 0 && (n % d) == 0)

Console.WriteLine(n + " делится нацело на " + d);

// Если теперь попытаться сделать то же самое без укороченного // логического оператора, то возникнет ошибка из-за деления на нуль, if(d != 0 & (n % d) == 0)

Console.WriteLine(n + " делится нацело на " + d);

}

}

Для исключения ошибки из-за деления на нуль в операторе i f сначала проверяется условие: равно ли нулю значение переменной d. Если оно равно нулю, то на этом выполнение укороченного логического оператора И завершается, а последующая операция деления по модулю не выполняется. Так, при первой проверке значение переменной d оказывается равным 2, поэтому выполняется операция деления по модулю. А при второй проверке это значение оказывается равным нулю, следовательно, операция деления по модулю пропускается, чтобы исключить деление на нуль. И наконец, выполняется обычный логический оператор И, когда вычисляются оба операнда. Если при этом происходит деление на нуль, то возникает ошибка при выполнении.

Укороченные логические операторы иногда оказываются более эффективными, чем их обычные аналоги. Так зачем же нужны обычные логические операторы И и ИЛИ? Дело в том, что в некоторых случаях требуется вычислять оба операнда логической операции И либо ИЛИ из-за возникающих побочных эффектов. Рассмотрим следующий пример программы.

// Продемонстрировать значение побочных эффектов.

using System;

class SideEffects { static void Main() { int i;

bool someCondition = false;

i = 0;

11 Значение переменной i инкрементируется,

11 несмотря на то, что оператор if не выполняется, if(someCondition & (++i < 100))

Console.WriteLine("Не выводится");

Console.WriteLine("Оператор if выполняется: " + i); // выводится 1

// В данном случае значение переменной i не инкрементируется,

// поскольку инкремент в укороченном логическом операторе опускается, if(someCondition && ( + + i < 100))

Console.WriteLine("Не выводится");

Console.WriteLine("Оператор if выполняется: " + i); // по-прежнему 1 !!

}

}

Прежде всего обратим внимание на то, что переменная someCondition типа bool инициализируется значением false. Далее проанализируем каждый оператор if. Как следует из комментариев к данной программе, в первом операторе i f переменная i инкрементируется, несмотря на то что значение переменной someCondition равно false. Когда применяется логический оператор &, как это имеет место в первом операторе i f, выражение в правой части этого оператора вычисляется независимо от значения выражения в его левой части. А во втором операторе i f применяется укороченный логический оператор. В этом случае значение переменной i не инкрементируется, поскольку левый операнд (переменная someCondition) имеет значение false, следовательно, выражение в правой части данного оператора пропускается. Из этого следует вывод: если в коде предполагается вычисление правого операнда логической операции И либо ИЛИ, то необходимо пользоваться неукороченными формами логических операций, доступных в С#.

И последнее замечание: укороченный оператор И называется также условным логическим оператором И, а укороченный оператор ИЛИ — условным логическим оператором ИЛИ.

Оператор присваивания

Оператор присваивания обозначается одиночным знаком равенства (=). В C# оператор присваивания действует таким же образом, как и в других языках программирования. Ниже приведена его общая форма.

имя_переменной = выражение

Здесь имя_переменной должно быть совместимо с типом выражения.

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

int х, у, z;

х = у = z = 100; // присвоить значение 100 переменным х, у и z

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

Составные операторы присваивания

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

X = X +    10;

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

X +=    10;

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

Рассмотрим еще один пример. Оператор

х = х - 100;

и оператор

X -=    100;

выполняют одни и те же действия. Оба оператора присваивают переменной х ее первоначальное значение, уменьшенное на 100.

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

имя_переменной ор = выражение

где ор — арифметический или логический оператор, применяемый вместе с оператором присваивания.

Ниже перечислены составные операторы присваивания для арифметических и логических операций.

+=

-=

*

/=

%=

&=

1 =

л _

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

У составных операторов присваивания имеются два главных преимущества. Во-первых, они более компактны, чем их "несокращенные" эквиваленты. И во-вторых, они дают более эффективный исполняемый код, поскольку левый операнд этих операторов вычисляется только один раз. Именно по этим причинам составные операторы присваивания чаще всего применяются в программах, профессионально написанных на С#.

Поразрядные операторы

В C# предусмотрен ряд поразрядных операторов, расширяющих круг задач, для решения которых можно применять С#. Поразрядные операторы воздействуют на отдельные двоичные разряды (биты) своих операндов. Они определены только для целочисленных операндов, поэтому их нельзя применять к данным типа bool, float или double.    1

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

Таблица 4.1. Поразрядные операторы

Оператор

Значение

&

Поразрядное И

1

Поразрядное ИДИ

Поразрядное исключающее ИДИ

>>

Сдвиг вправо

<<

Сдвйг влево

Дополнение до 1 (унарный оператор НЕ)

Поразрядные операторы И, ИЛИ, исключающее ИЛИ и НЕ

Поразрядные операторы И, ИЛИ, исключающее ИЛИ и НЕ обозначаются следую

щим образом: &, |, л и

~. Они выполняют те же функции, что и их логические аналоги,

рассмотренные выше.

Но в отличие от логических операторов, поразрядные операто-

ры действуют на уровне отдельных двоичных разрядов. Ниже приведены результаты

поразрядных операций с двоичными единицами и нулями.

р q

р & q plq pAq ~р

0 0

0 0 0 1

1 0

0 110

0 1

0 1 11*

1 1

1 .1 0 0

С точки зрения наиболее распространенного применения поразрядную операцию И можно рассматривать как способ подавления отдельных двоичных разрядов. Это означает, что если какой-нибудь бит в любом из операндов равен 0, то соответствующий бит результата будет сброшен в 0. Например:

1101 ООН 1010 1010

& _

1000 0010

В приведенном ниже примере программы демонстрируется применение поразрядного оператора & для преобразования нечетных чисел в четные. Для этой цели достаточно сбросить младший разряд числа. Например, число 9 имеет следующий двоичный вид: 0000 1001. Если сбросить младший разряд этого числа, то оно станет числом 8, а в двоичной форме — 0000 1000.

// Применить поразрядный оператор И, чтобы сделать число четным.

using System;

class MakeEven {

static void Main() { ushort num; ushort i;”

for(i =1; i <= 10; i++)    {

num = i;

Console.WriteLine("num: "■ + num); num = (ushort) (num & OxFFFE);

Console.WriteLine("num после сброса младшего разряда: "

+ num + "\n");

}

}

}

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

num: 1

num после сброса младшего разряда: О num: 2

num после сброса младшего разряда: 2 num: 3

num после сброса младшего разряда: 2 num: 4

num после сброса младшего разряда: 4 num: 5

num после сброса младшего разряда: 4 num: 6

num после сброса младшего разряда: 6 num: 7

num после сброса младшего разряда: 6 num: 8

num после сброса младшего разряда: 8 num: 9

num после сброса младшего разряда: 8 num: 10

num после сброса младшего разряда: 10

Шестнадцатеричное значение OxFFFE, используемое в поразрядном операторе И, имеет следующую двоичную форму: 1111 1111 1111 1110. Таким образом, поразрядная операция И оставляет без изменения все двоичные разряды в числовом значении переменной num, кроме младшего разряда, который сбрасывается в нуль. В итоге четные числа не претерпевают никаких изменений, а нечетные уменьшаются на 1 и становятся четными.

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

// Применить поразрядный оператор И, чтобы определить,

// является ли число нечетным.

using System;

class IsOdd {

static void Main() { ushort num;

num = 10;

if((num & 1) == 1)

Console.WriteLine("He выводится.") ;

num = 11;

if((num & 1) == 1)

Console.WriteLine(num + " — нечетное число.");

}

}

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

11 — нечетное число.

В обоих операторах if из приведенной выше программы выполняется поразрядная операция И над числовыми значениями переменной num и 1. Если младший двоичный разряд числового значения переменной num установлен, т.е. содержит двоичную 1, то результат поразрядной операции num & 1 оказывается равным 1. В противном случае он равен нулю. Поэтому оператор i f может быть выполнен успешно лишь в том случае, если проверяемое число оказывается нечетным.

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

// Показать биты, составляющие байт.

using System;

class ShowBits {

static void Main() { int t; byte val;

val = 123;

for(t=128; t > 0; t = t/2)    {

if((val & t) != 0) Console.Write("1 "); if((val & t) == 0) Console.Write("0 ");

}

}

}

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

01111011

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

Поразрядный оператор ИЛИ может быть использован для установки отдельных двоичных разрядов. Если в 1 установлен какой-нибудь бит в любом из операндов этого оператора, то в 1 будет установлен и соответствующий бит в другом операнде. Например:

1101 ООН

* 10101010

11111011

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

// Применить поразрядный оператор ИЛИ, чтобы сделать число нечетным.

using System;

class MakeOdd {

static void Main() { ushort num; ushort i;

for(i = 1; i <= 10; i++)    {

num = i;

Console.WriteLine("num: " + num); num = (ushort) (num | 1);

Console.WriteLine("num после установки младшего разряда: " + num + "\n");

}

}

}

Результат выполнения этой программы выглядит следующим образом.

num: 1

num после установки младшего разряда: 1

num: 2

num

после

установки

младшего

разряда:

3

num:

num

: 3

после

установки

младшего

разряда:

3

num:

num

: 4

после

установки

младшего

разряда:

5

num:

num

: 5

после

установки

младшего

разряда:

5

num:

num

: 6

после

установки

младшего

разряда:

7

num:

num

: 7

после

установки

младшего

разряда:

7

num: num

: 8

после

установки

младшего

разряда:

9

num: num

: 9

после

установку

младшего

разряда:

9

num: num

: 10 после

установки

младшего

разряда:

11

В приведенной выше программе выполняется поразрядная операция ИЛИ над каждым числовым значением переменной num и 1, поскольку 1 дает двоичное значение, в котором установлен младший разряд. В результате поразрядной операции ИЛИ над 1 и любым другим значением младший разряд последнего устанавливается, тогда как все остальные разряды остаются без изменения. Таким образом, результирующее числовое значение получается нечетным, если исходное значение было четным.

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

01111111 10111001

А

1100 0110

У поразрядного оператора исключающее ИЛИ имеется одно интересное свойство, которое оказывается полезным в самых разных ситуациях. Так, если выполнить сначала поразрядную операцию исключающее ИЛИ одного значения X с другим значением Y, а затем такую же операцию над результатом предыдущей операции и значением Y, то вновь получится первоначальное значение X. Это означает, что в приведенном ниже фрагменте кода

R1 = X л Y;

R2 = R1 л Y;

значение переменной R2 оказывается в итоге таким же, как и значение переменной X. Следовательно, в результате двух последовательно выполняемых поразрядных операций исключающее ИЛИ, в которых используется одно и то же значение, получается первоначальное значение. Этим свойством данной операции можно воспользоваться для написания простой программы шифрования, в которой некоторое целое значение служит в качестве ключа для кодирования и декодирования сообщения с помощью операции исключающее ИЛИ над символами этого сообщения. В первый раз операция исключающее ИЛИ выполняется для кодирования открытого текста в зашифрованный, а второй раз — для декодирования зашифрованного текста в открытый. Разумеется, такое шифрование не представляет никакой практической ценности, поскольку оно может быть легко разгадано. Тем не менее оно служит интересным примером для демонстрации результатов применения поразрядных операторов исключающее ИЛИ, как в приведенной ниже программе.

// Продемонстрировать применение поразрядного оператора исключающее ИЛИ. using System;

class Encode {

static void Main() { char chi = 'H'; char ch2 = 1i 1 ; char ch3 = 1!1; int key = 88;

Console.WriteLine("Исходное сообщение: " + chi + ch2 + ch3) ;

// Зашифровать сообщение, chi =    (char)    (chi    л    key);

ch2 =    (char)    (ch2    л    key)    ;

ch3 =    (char)    (ch3    л    key);

Console.WriteLine("Зашифрованное сообщение: " + chi + ch2 + ch3);

// Расшифровать сообщение.

chi =    (char)    (chi    л    key);    1

ch2 =    (char)    (ch2    л    key);

ch3 =    (char)    (ch3    л    key);

Console.WriteLine("Расшифрованное сообщение: " + chi + ch2 + ch3);

}

}

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

Исходное сообщение: Hi!

Зашифрованное сообщение: Qly Расшифрованное сообщение: Hi!

Как видите, в результате выполнения двух последовательностей поразрядных операций исключающее ИЛИ получается расшифрованное сообщение. (Еще раз напомним, что такое шифрование не имеет никакой практической ценности, поскольку оно, в сущности, ненадежно.)

Поразрядный унарный оператор НЕ (или оператор дополнения до 1) изменяет на обратное состояние всех двоичных разрядов операнда. Так, если некоторое целое значение А имеет комбинацию двоичных разрядов 1001 0110, то в результате поразрядной операции ~А получается значение с комбинацией двоичных разрядов 0110 1001.

В следующем примере программы демонстрируется применение поразрядного оператора НЕ с выводом некоторого числа и его дополнения до 1 в двоичном коде.

// Продемонстрировать применение поразрядного унарного оператора НЕ.

using System;

class NotDemo {

static void Main() { sbyte b = -34;

}

Console.WriteLine ();

// обратить все биты b = (sbyte) ~b;

}

}

}

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

11011110

00100001

Операторы сдвига

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

«

Сдвиг влево

>>

Сдвиг вправо

Ниже приведена общая форма для этих операторов:

значение « число_битов значение » число_битов

где число_битов — это число двоичных разрядов, на которое сдвигается указанное зна чение.

При сдвиге влево все двоичные разряды в указываемом значении сдвигаются на одну позицию влево, а младший разряд сбрасывается в нуль. При сдвиге вправо все двоичные разряды в указываемом значении сдвигаются на одну позицию вправо. Если вправо сдвигается целое значение безвнака, то старший разряд сбрасывается в нуль. А если вправо сдвигается целое значение со знаком, то разряд знака сохраняется. Напомним, что для представления отрицательных чисел старший разряд целого числа устанавливается в 1. Так, если сдвигаемое значение является отрицательным, то при каждом сдвиге вправо старший разряд числа устанавливается в 1. А если сдвигаемое значение является положительным, то при каждом сдвиге вправо старший разряд числа сбрасывается в нуль.

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

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

// Продемонстрировать применение операторов сдвига.

using System;

class ShiftDemo {

static void Main() { int val = 1;

for(int i = 0; i < 8; i++)    {

for(int t=128; t > 0; t = t/2)    {

if((val & t) != 0) Console.Write("1 "); if((val & t) == 0) Console.Write("0 ");

}

Console.WriteLine();

val = val <<1; // сдвиг влево

}

Console.WriteLine() ; val = 128;

for(int i = 0; i < 8; i++)    {

for(int t=128; t > 0; t = t/2)    {

if((val & t) != 0) Console.Write("1 "); if((val & t) == 0) Console.Write("0 ");

}

Console.WriteLine();

val = val >>1; // сдвиг вправо

}

}

}

Результат выполнения этой программы выглядит следующим образом.

00000001

00000010

00000100

00001000

00010000

00100000

01000000

10000000

10000000

01000000

00100000

00010000

00001000

00000100

00000010

00000001

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

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

using System;

class MultDiv {

static void Main() { int n;

n = 10;

Console.WriteLine("Значение переменной n: " + n) ;

// Умножить на 2.

n = n << l^-

Console.WriteLine ();

// Установить переменную n в исходное состояние, n = 10;

Console.WriteLine("Значение переменной n: " + n);

// Умножить на 2 тридцать раз. n = п << 30; // данные теряются

Console.WriteLine("Значение переменной п после " +

"сдвига на 30 позиций влево: " + п);

}

}

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

Значение переменной п после сдвига на 30 позиций влево: -2147483648

Обратите внимание на последнюю строку приведенного выше результата. Когда целое значение 10 сдвигается влево тридцать раз подряд, информация теряется, поскольку двоичные разряды сдвигаются за пределы представления чисел для типа int. В данном случае получается совершенно ''непригодное7' значение, которое оказывается к тому же отрицательным, поскольку в результате сдвига в старшем разряде, используемом в качестве знакового, оказывается 1, а следовательно, данное числовое значение должно интерпретироваться как отрицательное. Этот пример наглядно показывает, что применять операторы сдвига для умножения или деления на 2 следует очень аккуратно. (Подробнее о типах данных со знаком и без знака см. в главе 3.)

Поразрядные составные операторы присваивания

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

х = х л 127; х л= 127;

Оператор ?

Оператор ? относится к числу самых примечательных в С#. Он представляет собой условный оператор и часто используется вместо определенных видов конструкций if-then-else. Оператор ? иногда еще называют тернарным, поскольку для него требуются три операнда. Ниже приведена общая форма этого оператора.

Выражение 1 ? Выражение2 : Выражение3;

Здесь Выражение 1 должно относиться к типу bool, а Выражение2 и Выражение3 к одному и тому же типу. Обратите внимание на применение двоеточия и его местоположение в операторе ?.

Значение выражения ? определяется следующим образом. Сначала вычисляется Выражение!. Если оно истинно, то вычисляется Выражение2, а полученный результат определяет значение всего выражения ? в целом. Если же Выражение1 оказывается ложным, то вычисляется Выражение3, и его значение становится общим для всего выражения ?. Рассмотрим следующий пример, в котором переменной absval присваивается значение переменной val.

absval = val < 0 ? -val : val; // получить абсолютное значение переменной val

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

Ниже приведен еще один пример применения оператора ?. В данной программе одно число делится на другое, но при этом исключается деление на нуль.

// Исключить деление на нуль, используя оператор?.

using System;

class NoZeroDiv {

static void Main() { int result;

for(int i = -5; i < 6; i++)    {

result = i != 0 ? 100 / i : 0; if (i ! = 0)

Console.WriteLine("100 / " + i + " равно " + result);

}

}

}

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

100 / -5 равно -20 100 / -4 равно -25 100 / -3 равно -33 100 / -2 равно -50 100 / -1 равно -100 100 / 1 равно 100 100 / 2 равно 50 100 / 3 равно 33 100 / 4 равно 25 100 / 5 равно 20

Обратите особое внимание на следующую строку из приведенной выше программы.

result = i != 0 ? 100 / i : 0;

В этой строке переменной result присваивается результат деления числа 100 на значение переменной i. Но это деление осуществляется лишь в том случае, если значение переменной i не равно нулю. Когда же оно равно нулю, переменной result присваивается значение, обнуляющее результат.

Присваивать переменной результат выполнения оператора ? совсем не обязательно. Например, значение, которое дает оператор ?, можно использовать в качестве аргумента при вызове метода. А если все выражения в операторе ? относятся к типу bool, то такой оператор может заменить собой условное выражение в цикле или операторе

if. В приведенном ниже примере программы выводятся результаты деления числа 100 только на четные, ненулевые значения.

// Разделить только на четные, ненулевые значения.

using System;

class NoZeroDiv2 { static void Main() {

for(int i = -5; i < 6; i++)

if(i != 0 ? (i%2 == 0)    : false)

Console.WriteLine("100 / " + i + " равно " + 100 / i);

}

}

Обратите внимание на оператор if в приведенной выше программе. Если значение переменной i равно нулю, то оператор i f дает ложный результат. А если значение переменной i не равно нулю, то оператор if дает истинный результат, когда значение переменной i оказывается четным, и ложный результат, если оно нечетное. Благодаря этому допускается деление только на четные и ненулевые значения. Несмотря на то что данный пример служит лишь для целей демонстрации, подобные конструкции иногда оказываются весьма полезными.

Использование пробелов и круглых скобок

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

х=10/у*(127+х) ; х = 10 / у * (127 + х) ;

I

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

х = у/3-34*temp+127; х = (у/3) - (34*temp) + 127;

Предшествование операторов

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

Таблица 4.2. Предшествование операторов в C#

Наивысший

порядок

О

[]

.

++

--

checked

new sizeof typeof unchecked

(постфиксный)

(постфиксный)

j

(приведение

+ (унарный)

- (унарный)

++

--

типов)

(префиксный) префиксный)

/

о

о

+

-

«

»

<

>

1 =

<=

>=

is

&

А

1

&&

1 I

1 1 ? ?

? :

=

ор=

=>

Наинизший

порядок

ГЛАВА 5 Управляющие операторы

В этой главе речь пойдет об операторах, управляющих ходом выполнения программы на С#. Управляющие операторы разделяются на три категории: операторы выбора, к числу которых относятся операторы if и switch, итерационные операторы, в том числе операторы цикла for, while, do-while и foreach, а также операторы перехода: break, continue, goto, return и throw. За исключением оператора throw, который является неотъемлемой частью встроенного в C# механизма обработки исключительных ситуаций, рассматриваемого в главе 13, все остальные управляющие операторы представлены в этой главе.

Оператор if

Оператор i f уже был представлен в главе 2, а здесь он рассматривается более подробно. Ниже приведена полная форма этого оператора:

if (условие) оператор; else оператор;

где условие — это некоторое условное выражение, а оператор — адресат операторов if и else. Оператор else не является обязательным. Адресатом обоих операторов, if и else, могут также служить блоки операторов. Ниже приведена общая форма оператора i f, в котором используются блоки операторов.

if (условие)

{

последовательность операторов

else

{

последовательность операторов

}

Если условное выражение оказывается истинным, то выполняется адресат оператора if. В противном случае выполняется адресат оператора else, если таковой существует. Но одновременно не может выполняться и то и другое. Условное выражение, управляющее оператором if, должно давать результат типа bool.

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

// Определить, является ли числовое значение положительным или отрицательным.

using System;

class PosNeg {

static void Main() { int i;

for(i=-5; i <= 5; i++) {

Console.Write("Проверка " + i + ": ");

if(i < 0) Console.WriteLine("отрицательное число"); else Console.WriteLine("положительное число");

}

}

}

Результат выполнения этой программы выглядит следующим образом.

Проверка

-5

отрицательное

число

Проверка

-4

отрицательное

число

Проверка

-3

отрицательное

число

Проверка

-2

отрицательное

число

Проверка

-1

отрицательное

число

Проверка

0

положительное

число

Проверка

1

положительное

число

Проверка

2

положительное

число

Проверка

3

положительное

число

Проверка

4

положительное

число

Проверка

5

положительное

число

Если в данном примере значение переменной i оказывается меньше нуля, то выполнятся адресат оператора if. В противном случае выполняется адресат оператора else, одновременно они не выполняются.

Вложенные операторы if

Вложенным называется такой оператор if, который является адресатом другого оператора if или же оператора else. Вложенные операторы if очень часто применяются в программировании. Что же касается их применения в С#, то не следует забывать, что любой оператор else всегда связан с ближайшим оператором if, т.е. с тем

оператором if, который находится в том же самом блоке, где и оператор else, но не с другим оператором else. Рассмотрим следующий пример.

if (i == Ю) {

if (j < 20) -a = b; if(k > 100) с = d;

else a = с; // этот оператор else связан с оператором if(k > 100)

}

else a = d; // этот оператор else связан с оператором if(i == 10)

Как следует из комментариев к приведенному выше фрагменту кода, последний оператор else не связан с оператором if (j < 20), поскольку они не находятся в одном и том же блоке, несмотря на то, что этот оператор является для него ближайшим оператором if без вспомогательного оператора else. Напротив, последний оператор else связан с оператором if (i == 10). А внутренний оператор else связан с оператором i f (k > 100), поскольку этот последний является для него ближайшим оператором i f в том же самом блоке.

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

// Определить, является ли числовое значение // положительным, отрицательным или нулевым.

using System;

class PosNegZero { static void Main() { int i;

for(i=-5; i <= 5; i++)    {

Console.Write("Проверка " + i + ": "); if(i < 0) Console.WriteLine("отрицательное число"); else if(i == 0) Console.WriteLine("число без знака"); else Console.WriteLine("положительное число");

}

}

}

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

Проверка -5: отрицательное число Проверка -4: отрицательное число Проверка -3: отрицательное число Проверка -2: отрицательное число Проверка -1: отрицательное число Проверка 0: число без знака Проверка 1: положительное число Проверка 2: положительное число Проверка 3: положительное число Проверка 4: положительное число Проверка 5: положительное число

Конструкция if-else-if

В программировании часто применяется многоступенчатая конструкция if-else-if, состоящая из вложенных операторов if. Ниже приведена ее общая форма.

if(условие) оператор; else if (условие) оператор; else if (условие) оператор;

else

оператор;

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

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

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

// Определить наименьший множитель заданного // целого значения, состоящий из одной цифры.

using System;

class Ladder {

static void Main(), { int num;

for(num = 2; num < 12; num++) { if((num % 2) == 0)

Console.WriteLine("Наименьший множитель числа " + num + " равен 2.") else if((num % 3) == 0)

Console.WriteLine("Наименьший множитель числа " + num + " равен 3.") else if((num % 5) == 0)

Console.WriteLine("Наименьший множитель числа " + num + " равен 5.") else if((num % 7) == 0)

Console.WriteLine("Наименьший множитель числа " + num + " равен 7.") else

Console.WriteLine(num + " не делится на 2, 3, 5 или 7.");

}

}

}

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

Наименьший множитель числа 2 равен 2 Наименьший множитель числа 3 равен 3

Наименьший множитель числа 10 равен 2

11 не делится на 2, 3, 5 или 7.

Как видите, последний оператор else выполняется лишь в том случае, если не удается выполнить ни один из предыдущих операторов.

Оператор switch

Вторым оператором выбора в C# является оператор switch, который обеспечивает многонаправленное ветвление программы. Следовательно, этот оператор позволяет сделать выбор среди нескольких альтернативных вариантов дальнейшего выполнения программы. Несмотря на то что многонаправленная проверка может быть организована с помощью последовательного ряда вложенных операторов if, во многих случаях более эффективным оказывается применение оператора switch. Этот оператор действует следующим образом. Значение выражения последовательно сравнивается с константами выбора из заданного списка. Как только будет обнаружено совпадение с одним из условий выбора, выполняется последовательность операторов, связанных с этим условием. Ниже приведена общая форма оператора switch.

switch(выражение) { case константа1:

последовательность операторов break; case константа2:

последовательность операторов break; case константаЗ:

последовательность операторов break;

default:

последовательность операторов break;

}

Заданное выражение в операторе switch должно быть целочисленного типа (char, byte, short или int), перечислимого или же строкового. (О перечислениях и символьных строках типа string речь пойдет далее в этой книге.) А выражения других типов, например с плавающей точкой, в операторе switch не допускаются. Зачастую выражение, управляющее оператором switch, просто сводится к одной переменной. Кроме того, константы выбора должны иметь тип, совместимый с типом выражения. В одном операторе switch не допускается наличие двух одинаковых по значению констант выбора.

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

Ниже приведен пример программы, в котором демонстрируется применение оператора switch.

// Продемонстрировать применение оператора switch.

using System;

class SwitchDemo { static void Main() { int i;

for(i=0; i<10; i++) switch(i)    {

case 0:

Console.WriteLine("i равно нулю"); break; case 1:

Console.WriteLine("i равно единице"); break; case 2:

Console.WriteLine("i равно двум"); break; case 3:

Console.WriteLine("i равно трем"); break; case 4:

Console.WriteLine ("i равно четырем"); break;

default:    (

Console.WriteLine("i равно или больше пяти"); break;

}

}

}

Результат выполнения этой программы выглядит следующим образом.

i

равно

нулю.

i

равно

единице.

i

равно

двум.

i

равно

трем.

i

равно

четырем.

i

равно

или больше

пяти

i

равно

или больше

пяти

i

равно

или больше

пяти

i

равно

или больше

пяти

i

равно

или больше

пяти

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

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

В приведенном выше примере оператором switch управляла переменная i типа int. Как пояснялось ранее, для управления оператором switch может быть использовано выражений любого целочисленного типа, включая и char. Ниже приведен пример применения выражения и констант выбора типа char в операторе switch.

// Использовать элементы типа char для управления оператором switch.

using System;

class SwitchDemo2 { static void Main() { char ch;

for(ch='A'; ch<= ' E'; ch++) switch (ch) { case 'A1:

Console.WriteLine("ch содержит A"); break; case 'В':

Console.WriteLine("ch содержит В"); break; case 'С':

Console.WriteLine("ch содержит С"); break; case ' D' :

Console.WriteLine("ch содержит D"); break; case 'E':

Console.WriteLine("ch содержит E"); break;

}

}

}

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

ch содержит А ch содержит В ch содержит С ch содержит D ch содержит Е

Обратите в данном примере внимание на отсутствие ветви default в операторе switch. Напомним, что ветвь default не является обязательной. Когда она не нужна, ее можно просто опустить.

Переход последовательности операторов, связанных с одной ветвью case, в следующую ветвь case считается ошибкой, поскольку в C# должно непременно соблюдаться правило недопущения "провалов" в передаче управления ходом выполнения программы. Именно поэтому последовательность операторов в каждой ветви case оператора switch оканчивается оператором break. (Избежать подобных "провалов", можно также с помощью оператора безусловного перехода goto, рассматриваемого далее в этой главе, но для данной цели чаще применяется оператрр break.) Когда

в последовательности операторов отдельной ветви case встречается оператор break, происходит выход не только из этой ветви, но из всего оператора switch, а выполнение программы возобновляется со следующего оператора, находящегося за пределами оператора switch. Последовательность операторов в ветви default также должна быть лишена ''провалов'7, поэтому она завершается, как правило, оператором break.

Правило недопущения "провалов" относится к тем особенностям языка С#, которыми он отличается от С, C++ и Java. В этих языках программирования одна ветвь case может переходить (т.е. "проваливаться") в другую. Данное правило установлено в C# для ветвей case по двум причинам. Во-первых, оно дает компилятору возможность свободно изменять порядок следования последовательностей операторов из ветвей case для целей оптимизации. Такая реорганизация была бы невозможной, если бы одна ветвь case могла переходить в другую. И во-вторых, требование завершать каждую ветвь case явным образом исключает непроизвольные ошибки программирования, допускающие переход одной ветви case в другую.

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

// Пример "проваливания" пустых ветвей case.

using System;

class EmptyCasesCanFall { static void Main() { int i;

for(i=l; i < 5; i++) switch(i)    {

case 1: case 2:

case 3: Console.WriteLine("i равно 1, 2 или 3м); break;

case 4: Console.WriteLine("i равно 4"); break;

}

}

}

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

Если значение переменной i в данном примере равно 1, 2 или 3, то выполняется первый оператор, содержащий вызов метода WriteLine (). Такое расположение нескольких меток ветвей case подряд не нарушает правило недопущения "провалов"; поскольку во всех этих ветвях используется одна и та же последовательность операторов.

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

Вложенные операторы switch

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

switch(chi) {

case 'A': Console.WriteLine("Эта ветвь А — ^асть " +

"внешнего оператора switch.");

switch(ch2)    {

case 'A':

Console.WriteLine("Эта ветвь A — часть " +

"внутреннего оператора switch");

break; case 'В1: // ...

} // конец внутреннего оператора switch break; case 'В': // ...

Оператор цикла for

Оператор for уже был представлен в главе 2, а здесь он рассматривается более подробно. Вас должны приятно удивить эффективность и гибкость этого оператора. Прежде всего, обратимся к самым основным и традиционным формам оператора for.

Ниже приведена общая форма оператора for для повторного выполнения единственного оператора.

for{инициализация; условие; итерация) оператор;

А вот как выглядит его форма для повторного выполнения кодового блока:

for(инициализация; условие; итерация)

{

последовательность операторов;

}

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

Цикл for может продолжаться как в положительном, так и в отрицательном направлении, изменяя значение переменной управления циклом на любую величину. В приведенном ниже примере программы выводятся числа; постепенно уменьшающиеся от 100 до -100 на величину 5.

// Выполнение цикла for в отрицательном направлении.

using System;

class DecrFor {

static void Main() { int x;

for(x = 100; x > -100; x -= 5)

Console.WriteLine(x);

}

}

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

for(count=10; count < 5; count++)

x += count; // этот оператор не будет выполняться

Данный цикл вообще не будет выполняться, поскольку первоначальное значение переменной count, которая им управляет, сразу же оказывается больше 5. Это означает, что условное выражение count < 5 оказывается ложным с самого начала, т.е. еще до выполнения первого шага цикла.

Оператор цикла for — наиболее полезный для повторного выполнения операций известное число раз. В следующем примере программы используются два цикла for для выявления простых чисел в пределах от 2 до 20. Если число оказывается непростым, то выводится наибольший его множитель.

// Выяснить, является ли число простым. Если оно // непростое, вывести наибольший его множитель.

using System;

class FindPrimes { static void Main() { int num; int i; int factor; bool isprime;

for(num = 2; num < 20; num++) { isprime = true; factor = 0;

// Выяснить, делится ли значение переменной num нацело. for(i=2; i <= num/2; i++)    {

if((num % i) == 0)    {

// Значение переменной num делится нацело.

// Следовательно, это непростое число, isprime = false; factor = i;

}

if(isprime)

Console.WriteLine(num + " — простое число."); else

-Console.WriteLine("Наибольший множитель числа " + num + " равен " + factor);

}

}

}

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

2    — простое число

3    — простое число

Наибольший множитель

числа

4

равен 2

5 — простое число Наибольший множитель

числа

6

равен 3

7 — простое число Наибольший множитель

числа

8

равен 4

Наибольший множитель

числа

9

равен 3

Наибольший множитель

числа

10

равен 5

11 — простое число Наибольший множитель

числа

12

равен 6

13 — простое число Наибольший множитель

числа

14

равен 7

Наибольший множитель

числа

15

равен 5

Наибольший множитель

числа

16

равен 8

17 — простое число Наибольший множитель

числа

18

равен 9

19 — простое число

Некоторые разновидности оператора цикла for

Оператор цикла for относится к самым универсальным операторам языка С#, поскольку он допускает самые разные варианты своего применения. Некоторые разновидности оператора цикла for рассматриваются ниже.

Применение нескольких переменных управления циклом

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

// Использовать запятые в операторе цикла for.

using System;

class Comma {

static void Main() { int i, j;

for(i=0, j = 10; i < j; i++, j —)

Console.WriteLine("i и j: " + i + " " + j) ;

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

i

и

j :

0

10

i

и

j :

1

9

i

и

j :

2

8

i

и

j :

3

7

i

и

j :

4

6

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

Ниже приведен практический пример применения нескольких переменных управления циклом в операторе for. В этом примере программы используются две переменные управления одним циклом for для выявления наибольшего и наименьшего множителя целого числа (в данном случае — 100). Обратите особое внимание на условие окончания цикла. Оно опирается на обе переменные управления циклом.

// Использовать запятые в операторе цикла for для // выявления наименьшего и наибольшего множителя числа.

using System;    >

class Comma {

static void Main() { int i, j;

int smallest, largest; int num;

num = 100;

smallest = largest = 1;

for(i=2, j=num/2; (i <= num/2) & (j >= 2); i++, j—)    {

if((smallest == 1) & ((num % i) == 0)) smallest = i;

if ( (largest == 1) & ((num % j) == 0)) largest = j;

}

Console.WriteLine("Наибольший множитель: " + largest);

Console.WriteLine("Наименьший множитель: " + smallest);

}

}

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

Наибольший множитель: 50 Наименьший множитель: 2

Благодаря применению двух переменных управления циклом удается выявить наименьший и наибольший множители числа в одном цикле for. В частности, управляющая переменная i служит для выявления наименьшего множителя. Первоначально ее значение устанавливается равным 2 и затем инкрементируется до тех пор, пока не превысит половину значения переменной num. А управляющая переменная j служит для выявления наибольшего множителя. Ее значение первоначально устанавливается равным половине значения переменной num и затем декрементируется до тех пор, пока не станет меньше 2. Цикл продолжает выполняться до тех пор, пока обе переменные, i и j, не достигнут своих конечных значений. По завершении цикла оба множителя оказываются выявленными.

Условное выражение

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

// Условием выполнения цикла может служить любое выражение типа bool.

using System;

class forDemo {

static void Main() { int i, j;

bool done = false;

for(i=0, j=100; !done; i++, j—)    {

if(i*i >= j) done = true;

Console.WriteLine("i, j: " + i + " " + j);

}

}

}

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

i, j

0 100

i/ j

1 99

i, j

2 98

i, j

3 97

if j

4 96

1a j

5 95

1a j

6 94

1a j

7 93

j

8 92

1a j

9 91

ir j

10 90

В данном примере цикл for повторяется до тех пор, пока значение переменной done типа не окажется истинным (true). Истинное значение переменной done устанавливается в цикле, когда квадрат значения переменной i оказывается больше или равным значению переменной j.

Отсутствующие части цикла

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

// Отдельные части цикла for могут оставаться пустыми.

using System;

class Empty {

static void Main() { int i;

for (i = 0; i < 10; )    {

Console.WriteLine("Проход №" + i);

i++; // инкрементировать переменную управления циклом

}

}

}

В данном примере итерационное выражение в определении цикла for оказывается пустым, т.е. оно вообще отсутствует. Вместо этого переменная i, управляющая циклом, инкрементируется в теле самого цикла. Это означает, что всякий раз, когда цикл повторяется, значение переменной i проверяется на равенство числу 10, но никаких других действий при этом не происходит. А поскольку переменная i инкрементируется в теле цикла, то сам цикл выполняется обычным образом, выводя приведенный ниже результат.

Проход №0 Проход №1 Проход №2 Проход №3 Проход №4 Проход №5 Проход №6 Проход №7 Проход №8 Проход №9

В следующем примере программы из определения цикла for исключена инициализирующая часть.

// Исключить еще одну часть из определения цикла for.

using System;

class Empty2 {

static void Main() { int i;

i = 0; // исключить инициализацию из определения цикла for(; i < 10; )    {

Console.WriteLine("Проход №" + i);

i++; // инкрементировать переменную управления циклом

}

}

}

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

Бесконечный цикл

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

for(;;) // цикл, намеренно сделанный бесконечным {

//. . .

}

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

Циклы без тела

В C# допускается оставлять пустым тело цикла for или любого другого цикла, поскольку пустой оператор с точки зрения синтаксиса этого языка считается действительным. Циклы без тела нередко оказываются полезными. Например, в следующей программе цикл без тела служит для получения суммы чисел от 1 до 5.

// Тело цикла может быть пустым, using system;

class Empty3 {

static void Main() { int i;

int sum = 0;

• // получить сумму чисел от 1 до 5 for(i = 1; i <= 5; sum += i++);

Console.WriteLine("Сумма равна " + sum);

}

}

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

Сумма равна 15

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

sum += i++

Подобные операторы не должны вас смущать. Они часто встречаются в программах, профессионально написанных на С#, и становятся вполне понятными, если разобрать их по частям. Дословно приведенный выше оператор означает следующее: сложить со значением переменной sum результат суммирования значений переменных sum и i, а затем инкрементировать значение переменной i. Следовательно, данный оператор равнозначен следующей последовательности операторов.

sum = sum + i;

i + + ;

Объявление управляющих переменных в цикле for

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

// Объявить переменную управления циклом в самом цикле for. using System;

class ForVar {

static void Main() { int sum = 0; int fact = 1;

// вычислить факториал чисел от 1 до 5 for(int i = 1; i <= 5; i++)    {

sum += i; // Переменная i действует в цикле, fact *= i;

}

// А здесь переменная i недоступна.

Console.WriteLine("Сумма равна " + sum);

Console.WriteLine("Факториал равен " + fact);

}

}

Объявляя переменную в цикле for, не следует забывать о том, что область действия этой переменной ограничивается пределами оператора цикла for. Это означает, что за пределами цикла действие данной переменной прекращается. Так, в приведенном выше примере переменная i оказывается недоступной за пределами цикла for. Для того чтобы использовать переменную управления циклом в каком-нибудь другом месте программы, ее нельзя объявлять в цикле for.

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

Оператор цикла while

Еще одним оператором цикла в C# является оператор while. Ниже приведена общая форма этого оператора:

while (условие) оператор;

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

Ниже приведен простой пример программы, в которой цикл while используется для вычисления порядка величины целого числа.

// Вычислить порядок величины целого числа, using System;

class WhileDemo {

static void Main() { int num; int mag;

num = 435679; mag = 0;

Console.WriteLine("Число: " + num);

while(num > 0)    {

mag++;

num = num / 10;

};

Console.WriteLine("Порядок величины: " + mag);

}

}

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

Число: 435679 Порядок величины: 6

Приведенный выше цикл while действует следующим образом. Сначала проверяется значение переменной num. Если оно больше нуля, то переменная mag, выполняющая роль счетчика порядка величины, инкрементируется, а значение переменной num делится на 10. Цикл повторяется до тех пор, пока значение переменной num остается больше нуля. Как только оно окажется равным нулю, цикл завершается, а в переменной mag остается порядок величины первоначального числового значения.

Как и в цикле for, в цикле while проверяется условное выражение, указываемое в самом начале цикла. Это означает, что код в теле цикла может вообще не выполняться, а также избавляет от необходимости выполнять отдельную проверку перед самим циклом. Данное свойство цикла while демонстрируется в следующем примере программы, где вычисляются целые степени числа 2 от 0 до 9.

// Вычислить целые степени числа 2.

using System;

class Power {

static void Main() { int e; int result;

for (int i=0; i < 10; i++)    {

result = 1; e = i;

while (e > 0)    {

result *= 2; e—;

}

Console.WriteLine ("2 в степени " + i + " равно " + result);

}

}

}

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

Обратите внимание на то, что цикл while выполняется только в том случае, если значение переменной е больше нуля. А когда оно равно нулю, как это имеет место на первом шаге цикла for, цикл while пропускается.

Оператор цикла do-while

Третьим оператором цикла в C# является оператор do-while. В отличие от операторов цикла for и while, в которых условие проверялось в самом начале цикла, в операторе do-while условие выполнения цикла проверяется в самом его конце. Это означает, что цикл do-while всегда выполняется хотя бы один раз. Ниже приведена общая форма оператора цикла do-while.

do {

операторы;

} while (условие) ;

При наличии лишь одного оператора фигурные скобки в данной форме записи необязательны. Тем не менее они зачастую используются для того, чтобы сделать конструкцию do-while более удобочитаемой и не путать ее с конструкцией цикла while. Цикл do-while выполняется до тех пор, пока условное выражение истинно.

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

// Отобразить цифры целого числа в обратном порядке.

using System;

class DoWhileDemo { static void Main() { int num; int nextdigit;

num = 198;

Console.WriteLine("Число: " + num);

Console.Write("Число в обратном порядке: "); do {

nextdigit = num % 10;

Console.Write(nextdigit); num = num / 10;

} while(num > 0);

Console.WriteLine() ;

}

}

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

Число: 198

Число в обратном порядке: 8 91

Приведенный выше цикл действует следующим образом. На каждом его шаге крайняя слева цифра получается в результате расчета остатка от деления целого числа (значения переменной num) на 10. Полученная в итоге цифра отображается. Далее значение переменной num делится на 10. А поскольку это целочисленное деление, то в его результате крайняя слева цифра отбрасывается. Этот процесс повторяется до тех пор, пока значение переменной num не достигнет нуля.

Оператор цикла foreach

Оператор цикла f oreach служит для циклического обращения к элементам коллекции, которая представляет собой группу объектов. В C# определено несколько видов коллекций, к числу которых относится массив. Подробнее о ци