Programmeerimiskeele C# õppematerjal › osakond › opilaste_tood › seminari_ja... · В c# предусмотрен богатый набор встроенных типов

Tallinna Ülikool

Informaatikaosakond

Mamonova Jana

Programmeerimiskeele C# õppematerjalProseminaritöö

Juhendaja: Jaagup Kippar

Tallinn 2006

Содержание Содержание...................................................................................................................................2 Введение........................................................................................................................................5 Для знакомства с новым языком программирования имеющего, вне всякого сомнения, богатые возможности, далее вашему вниманию предоставлен учебный материал вместе с учебной программой. Также был составлен анализ, необходимый для просеминарской работы.............................................................................................................................................6 Построение работы.......................................................................................................................7 Учебная программа.......................................................................................................................9 Учебная неделя...........................................................................................................................12 Тема..............................................................................................................................................12 Основные понятия......................................................................................................................12 1....................................................................................................................................................12 2....................................................................................................................................................12 Типы данных...............................................................................................................................12 Структуры; Типы значений; Ссылочные типы; Целые типы; Типы с плавающей точкой; Логический тип; Тип decimal......................................................................................................12 3....................................................................................................................................................12 Переменные. Операторы............................................................................................................12 Статистические переменные; Экземплярные переменные; Локальные переменные; ....12 4....................................................................................................................................................12 Константы; Целочисленные константы; Константы с плавающей точкой; Строковый литерал..........................................................................................................................................12 5....................................................................................................................................................12 Управляющие конструкции........................................................................................................12 Инструкции выбора (IF, SWITCH); Итерационные инструкции (FOR, WHILE, DO-WHILE, FOREACH); Инструкция перехода (GOTO). ........................................................12 6....................................................................................................................................................12 Массивы.......................................................................................................................................12 7....................................................................................................................................................12 Контрольная работа....................................................................................................................12 8....................................................................................................................................................12 Классы..........................................................................................................................................12 Класс; Члены класса; Модификатор доступа.........................................................................12 9....................................................................................................................................................12 Классы. Конструкторы классов.................................................................................................12 Конструкторы классов; Поля; Методы; Свойства...................................................................12 10..................................................................................................................................................12 Резерв...........................................................................................................................................12

Урок 1, 2...................................................................................................................................14 Урок 3, 4...................................................................................................................................16 Урок 5, 6...................................................................................................................................18 Урок 7, 8...................................................................................................................................20 Урок 9, 10.................................................................................................................................22 Урок 11, 12...............................................................................................................................24

1. Повторение изученного ранее материала. Ответы на возникшие вопросы.......................24 Урок 13, 14...............................................................................................................................29 Урок 15, 16...............................................................................................................................32

Анализ учебного материала.......................................................................................................38 Учебник программирования на языке C# ............................................................................. 38 Проведение анализа ................................................................................................................ 38

2

Проработка материала, использованного в учебнике ........................................................ 38 Подведение итогов, выявление плюсов и минусов ............................................................. 41 Способ проведения уроков программирования .................................................................. 42

Заключение..................................................................................................................................44 Использованная литература.......................................................................................................45 Краткое описание работы на эстонском языкеLühikirjeldus eesti keeles...............................................................................................................46 Учебный материал начального курса языка C#.......................................................................50

1. Общее описание языка C#.................................................................................................50 2. Что такое NET Runtime?.....................................................................................................51 3. Использование C#...............................................................................................................52 4. Типы данных в С#...............................................................................................................54 Типы значений в C# ............................................................................................................. 54 Типы значений: ...................................................................................................................... 55 Целые типы: ............................................................................................................................ 55 Согласно этой таблице, в C# определены обе версии всех целочисленных типов: как со знаком, так и без него. Различие между этими версиями заключается в способе интерпретации старшего разряда. Если в программе задано целочисленное значение со знаком, то компилятор сгенерирует код, в котором предусматривается, что старший разряд такого значения используется в качестве флага знака (sign flag). Если флаг знака равен нулю, то число положительно, если он равен 1, то число отрицательно. Отрицательные числа почти всегда представляются в виде дополнения до двух. Для получения дополнительного кода сначала все разряды числа, за исключением знакового, инвертируются, а затем результат инвертирования суммируется с единицей. Наконец, флаг знака устанавливается равным единице. ...................................................................... 56 Типы с плавающей точкой ..................................................................................................... 56 Логический тип ....................................................................................................................... 56 В С# не определено ни одного преобразования значения типа bool в целочисленное значение. Например, число 1 не преобразуется в значение true, а число 0 – в значение false. ........................................................................................................................................... 57 Тип decimal .............................................................................................................................. 57 5. Переменные.........................................................................................................................58 6. Операторы............................................................................................................................59 7. Константы............................................................................................................................61 8. Управляющие конструкции................................................................................................62 Операторы If, switch, if..else ................................................................................................... 62

If.............................................................................................................................................62switch.....................................................................................................................................62if..else.....................................................................................................................................63

Циклы for и foreach. ................................................................................................................ 64 for...........................................................................................................................................64foreach...................................................................................................................................65

Циклы while и do-while. ......................................................................................................... 66 while.......................................................................................................................................66do-while.................................................................................................................................67

Цикл goto ................................................................................................................................. 67 9. Массивы...............................................................................................................................69 Одномерные массивы ............................................................................................................. 69 Многомерные массивы ........................................................................................................... 71 Рваные массивы ...................................................................................................................... 72 10. Классы................................................................................................................................75 Конструкторы классов ............................................................................................................ 78

3

Поля .......................................................................................................................................... 80 Методы ..................................................................................................................................... 81 Свойства ................................................................................................................................... 82 11. Вспомогательный материал.............................................................................................84

Работа с консолью.......................................................................................................................84

4

Введение Мой учебник предназначен для изучения языка программирования C# на уроках

информатики в 12 классе. Работа содержит теоретический материал о языке

программирования C#, примеры работы на этом языке, а также показано на уроках методы

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

теоретически, так и практически.

Настоящая книга не является вводным курсом в программирование; она предполагает

определенное знакомство с основными понятиями программирования, такими как

переменные, типы данных, массивы, классы. Тем не менее, и новичок в

программировании должен оказаться в состоянии самостоятельно освоить язык, хотя при

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

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

Данный учебник – не исчерпывающее пособие по С#. Для повышения уровня знаний и

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

источникам. Несомненно, их станет еще больше по мере роста популярности языка.

История происхождения языка C#

Язык C# является наиболее известной новинкой в области создания языков

программирования. В отличие от 60-х годов XX века – периода бурного языкотворчества –

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

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

такой. Разработанный компанией Microsoft (C# был создан в конце 90-х годов, а впервые

увидел свет в середине 2000 года), будучи наследником C++, он с первых своих шагов

получил мощную поддержку. Создателем языка является сотрудник Microsoft Андреас

Хейлсберг (Andres Hejlsberg). Он стал известным в мире программистов задолго до того,

как пришел в Microsoft. Хейлсберг входил в число ведущих разработчиков одной из самых

популярных сред разработки – Delphi. В Microsoft он участвовал в создании версии Java,

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

Как отмечал сам Андреас Хейлсберг, C# создавался как язык компонентного

программирования, и в этом одно из главных достоинств языка, направленное на

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

факторов отметим следующие:

• язык C# создавался параллельно с платформой Framework.Net и в полной мере

учитывает все его возможности – как FCL, так и CLR;

5

• C# является полностью объектно-ориентированным языком, где даже типы,

встроенные в язык, представлены классами;

• C# является мощным объектным языком с возможностями наследования и

универсализации;

• C# является наследником языков C/C++, сохраняя лучшие черты этих популярных

языков программирования. Общий с этими языками синтаксис, знакомые

операторы языка облегчают переход программистов от С++ к C#;

• сохранив основные черты своего великого родителя, язык стал проще и надежнее;

• мощная библиотека каркаса поддерживает удобство построения различных типов

приложений на C#, позволяя легко строить Web-службы, другие виды компонентов,

достаточно просто сохранять и получать информацию из базы данных и других

хранилищ данных;

• реализация, сочетающая построение надежного и эффективного кода, является

немаловажным фактором, способствующим успеху C#.

Для знакомства с новым языком программирования имеющего, вне всякого сомнения,

богатые возможности, далее вашему вниманию предоставлен учебный материал вместе с

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

работы.

6

Построение работы Составленный учебник представляет собой лишь облегченный материал обучения

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

информатики в 12 классах. Учебник изначально был предназначен для того, чтобы помочь

ученику научиться программировать на языке C#. Он содержит введение, отдельные

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

построено в основном на чтении, написании и разборе примеров, а не голой формулировке

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

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

С#.

Чтобы облегчить читателю овладение таким огромным объемом материала,

теоретическая часть учебника разделена на 11 глав:

1 Общее описание языка С#

2 Что такое NET Runtime?

3 Использование C#

4 Типы данных в С#

5 Переменные

6 Операторы

7 Константы

8 Управляющие конструкции

9 Массивы

10 Классы

11 Работа с консолью

В первой главе содержится исчерпывающееся описание языка C#, а также пояснения,

зачем и для чего данный язык был разработан.

Во второй главе описывается среда (NET Runtime) в которой выполняется код,

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

описывается два важных средства: CLR – система, которая управляет выполнением

пользовательских программ, то есть делает программы переносимыми, поддерживает

многоязыковое программирование и обеспечивает безопасность. И второе средство –

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

В третей части излагается практический материал использования C#. На основе

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

подробно разобраны значения каждой строки программы.

7

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

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

C# предусмотрен богатый набор встроенных типов данных, что позволяет использовать

этот язык для широкого диапазона приложений.

В пятой главе кратко рассматриваются переменные.

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

мощные рычаги управления при создании разнообразнейших выражений и их

вычислении.

Седьмая глава представляет нам константы или литералы. Это фиксированные

значения, представленные в понятной форме.

Управляющие конструкции – это большая тема, где рассматриваются инструкции

управления ходом выполнения C# программы. Мы знакомимся с тремя категориями

управляющих конструкций: инструкции выбора (IF, SWITCH), итерационные инструкции

(состоящие из FOR, WHILE, DO-WHILE и FOREACH) и инструкции перехода (GOTO).

Чтобы операторы были более понятными, в учебнике даны различные примеры.

Следующая глава довольно интересна и представляет понятия массива. Нам

становится известно, что массивы бывают одномерные, многомерные и рваные. В главе

собраны основные понятия и определения, различные примеры фрагментов, для

наглядности приведена таблица.

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

классом определяется природа объекта. Поскольку все C# – программы оформляются в

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

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

данной главе вы сумеете оценить богатые возможности класса. Также кроме основных

понятий в этой главе можно увидеть пример класса с запущенной программой для

наглядного обзора работы, таблицу описателей доступа. Знакомимся с понятиями – поля,

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

Последняя глава предназначена для вспомогательного материала, где описывается

правило работы с консолью.

Практическая часть представляет собой методический материал, состоящих из 16

уроков. У всех уроков почти одна схожая схема – вначале идет трактовка теоретического

материала с наглядными примерами, а затем контроль знаний методом выполнения

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

усвоенных умений и навыков, состоящая из двух заданий.

8

Учебная программа В наше время инфраструктура развивается достаточно быстро, у детей появляется

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

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

такие как работа с текстом, работа с таблицами и презентации изучаются уже гораздо

раньше, начиная с 3-4 класса. В старших классах в программе обучения по информатики

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

вводить язык программирования C# (C-sharp).

Не секрет, что современных учеников компьютеры интересуют больше, чем что - либо

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

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

его закреплению и запоминанию.

Также стоит учесть, что в школах на урок информатики выделяют не так уж много

часов: один или два часа в неделю. На самостоятельное изучение материала дома тоже

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

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

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

Рассмотрим далее критерии оценивания:

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

1. Оценивание по информатике осуществляет учитель – предметник, который в начале

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

по предмету.

2. Родители вправе получить информацию о порядке оценивания по предмету от учителя

– предметника, а также могут ознакомиться с порядком оценивания по предмету в

школьной библиотеке, методическом кабинете или на интернет-сайте школы.

3. При оценивании учитываются:

• сложность материала;

• самостоятельность и творческий характер применения знаний;

• уровень приобретённых знаний, умений и навыков учащихся по отношению к

компетенциям, требуемым в школьной программе обучения;

• правильность ответов, точность и логичность применения терминологии;

• компетентность ученика в работе с программным обеспечением;

• наличие и характер ошибок, допущенных учащимися;

9

• особенности развития учащихся.

4. Оценивание итогов обучения делится на:

• текущее оценивание в течение учебного процесса;

• итоговое оценивание.

4.1 Текущее оценивание – есть оценивание единичных результатов учёбы, а также

оценивание знаний, умений и навыков по какой - либо целостной части учебного

материала. Текущие оценки могут быть поставлены:

• за контрольную работу;

• за практическую работу;

• за индивидуальные ответы учащегося на уроке и во внеурочное время;

• за работу в группе по какой–либо теме;

• за самостоятельную, практическую, фронтальную, уровневую работу;

В начале учебного курса учитель доводит до сведения учащихся требования,

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

Пересдача контрольных работ осуществляется в течение 14 дней после получения

неудовлетворительной оценки. Если ученик болел длительное время, он имеет

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

4.2 Итоговыми оценками в гимназии являются курсовые оценки и оценки за школьную

ступень. Курсовая оценка выставляется на основании не менее трёх текущих оценок.

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

оценок в 10-12 классах.

5. По окончании 12 класса учащийся имеет право выбрать информатику в качестве

предмета, по которому сдаёт школьный экзамен. Результаты школьного экзамена

оценивает школьная комиссия. Результат школьного экзамена выставляется в

свидетельство о среднем образовании.

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

Оценка «5» (очень хорошо) ставится, если учащийся:

• полностью владеет содержанием материала в объёме, предусмотренном

программой;

• излагает материал грамотным языком;

• чётко использует точность и логичность применения терминологии;

• способен показать знания на конкретных примерах;

• умеет применить знания в нестандартной ситуации;

10

• понимает связь с ранее изученным материалом.

Оценка «4» (хорошо) ставится, если учащийся:

• недостаточно полно владеет содержанием материала;

• допускает при выполнении задания 1-2 ошибки, которые не искажают

содержания, но умеет их исправить после замечания учителя;

• затрудняется применить знания в незнакомой ситуации.

Оценка «3» (удовлетворительно) ставится, если учащийся:

• неполно владеет содержанием материала, но показывает общее понимание;

• имеет затруднения в определении понятий и использовании терминологии;

• допускает значительные ошибки.

Оценка «2» (недостаточно) ставится, если учащийся:

• не раскрыл основное содержание учебного материала;

• не овладел основными знаниями и умениями в соответствии с программой;

• допускает грубые ошибки при ответе.

Оценка «1» (слабо) ставится, если учащийся:

• обнаружил полное незнание и непонимание изучаемого материала;

• не смог ответить ни на один из поставленных вопросов.

Материал рассчитан на один курс, длительность которого предполагается 10 недель.

Данный курс представляет собой уроки информатики в 12 классе по одному сдвоенному

уроку (45 + 45 минут) один раз в неделю. В итоге на изучение темы предоставляется 20

уроков по 45 минут, из них 18 уроков конкретно на изучение материала и 2 урока на

дополнительно возникшие вопросы: исправление оценок, выявление недопонимания по

изученной теме и так далее.

11

Рабочий план учителя:

Учебная неделя Тема Основные понятия

1 Общее описание языка C#.Что такое NET Runtime?Использование C#.

C# (си-шарп); NET Runtime;Common Language Runtime.

2 Типы данных. Структуры; Типы значений; Ссылочные типы; Целые типы; Типы с плавающей точкой; Логический тип; Тип decimal.

3 Переменные. Операторы. Статистические переменные; Экземплярные переменные; Локальные переменные; Арифметические операторы; Операторы отношений; Логические операторы; Инкремент и декремент.

4 Константы. Константы; Целочисленные константы; Константы с плавающей точкой; Строковый литерал.

5 Управляющие конструкции. Инструкции выбора (IF, SWITCH); Итерационные инструкции (FOR, WHILE, DO-WHILE, FOREACH); Инструкция перехода (GOTO).

6 Массивы. Массив; Индексы; Размерность массива; Динамический массив; Одномерные массивы; Многомерные массивы; Рваные массивы.

7 Массивы. Контрольная работа

8 Классы. Класс; Члены класса; Модификатор доступа.

9 Классы. Конструкторы классов. Конструкторы классов; Поля; Методы; Свойства.

10 Резерв.

12

Практическое применение языка C# Предоставленный ниже материал создавался индивидуально с целью показать

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

приведены уроки, основанные на теоретическом материале учебника и содержащие

практические задания. Данный методический материал, а также практические задания,

были придуман мною, как показатель, каким образом можно построить урок, используя

созданный учебник.

Каждый урок начинается с определения темы и постановки конкретной цели урока,

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

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

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

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

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

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

Урок программирования проводится сдвоенным уроком (45 + 45 минут) один раз в

неделю.

13

Урок 1, 2.Темы:

1. Общее описание языка C#

2. Что такое NET Runtime

3. Использование C#

Цель:

Ознакомление с программой C#. Практическое знакомство с программированием на этом

языке на основе простейших примеров. Закрепление материала с помощью выполнения

заданий.

Ход урока:

1. Объяснение нового материала, опираясь на теорию (см.[1,2,3], стр. 48-51).

2. Практическое применение языка программирования C# на простейшем примере

программы «Hello World» и дальнейшее подробное объяснения работы этой

программы (см.[3], стр. 50-51).

3. Используя наглядно рассмотренный пример, самостоятельно выполнить задания:

Задание 1:

Напишите программу, выводящую на экран надпись «I like C# Programming».

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

using System;

class Urok1{ static void Main(){ Console.WriteLine("I like C# Programming"); }}

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

14

Задание 2:

Напишите программу, выводящую на экран две переменные x и y , с присвоенными им

любыми целочисленными значениями. (Для объявления переменной целочисленного типа

достаточно поставить перед ее именем ключевое слово int).

Стоит запомнить, что подобно большинству языков программирования, C#

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

Сложение (+), вычитание (–), Умножение (*), Деление (/).


using System;

class Primer2{ static void Main(){ int x; //Здесь объявляется переменная. int y; //Здесь объявляется еще одна переменная. x = 100; // Здесь переменной x присваивается значение 100. Console.WriteLine("x содержит " + x); y = x / 2;

Console.Write("y содержит x / 2:"); Console.WriteLine(y); }}


15

Урок 3, 4.Тема: Типы данных

Цель: Изучение технологии применения различных типов данных для составления

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

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

Ход урока:

1. Теоретическое знакомство с материалом (см.[4], стр. 52-55).

2. Подробное рассмотрение таблицы «Типы значений» (см.[4], стр. 53) и объяснение

ее предназначения.

3. Знакомство с целыми типами и с типами с плавающей точкой, а также изучение

логического типа и типа decimal и с возможностью их применения.

4. Проверка усвоенных знаний – выполнение практических заданий.

Задание 1:

Создать программу, которая вычисляет сумму чисел от 1 до 100 (Используем тип byte).


using System;

class Urok2{ public static void Main(){ byte x; int sum; sum = 0; //инициализация переменной sum for (x = 1; x <= 100; x++) sum = sum + x; Console.WriteLine("Сумма чисел от 1 до 100 равна " + sum); }}


16

Задание 2:

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


using System;

class Radius{ public static void Main(){ double r; double area;

area = 10.0; r = Math.Sqrt(area / 3.1416); Console.WriteLine("Радиус равен " + r); }}


17

Урок 5, 6.Тема: Константы

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

Расширение и углубление знаний учащихся на тему «Константы» при помощи

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

задания.

Ход урока:

1. Самостоятельное краткое ознакомление с новым материалом, опираясь на теорию

(см.[7], стр. 59).

2. Подробное объяснение учителем управляющих последовательностей символов,

используя дополнительный материал, достойный внимания (см. [Приложение 1],

стр. 34).

3. Практическое применение усвоенных знаний. Используя полученную информацию

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

Задание 1:

Написать программу, используя следующие ESC-последовательности: \n, \t, \".


using System;

class Constanta{ public static void Main(){ Console.WriteLine( "Первая строка\nВторая строка\nТретья строка"); Console.WriteLine("Один\tДва\tТри"); Console.WriteLine("Четыре\tПять\tШесть");

//Вставляем кавычки. Console.WriteLine("\"Привет!\", сказала я."); }}


18

Задание 2:

На основе первого задания, используя те же ESC-последовательности, написать

следующую программу: в первой, второй и третей строке выводятся слова – Фрукты,

Овощи, Ягода соответственно. Далее, программа впечатывает следующее:

Яблоки 15 крон

Томаты 20 крон

Сливы 18 крон


using System;

class Constanta2{ public static void Main(){ Console.WriteLine( "Фрукты\nОвощи\nЯгода"); Console.WriteLine("Яблоки\t15крон"); Console.WriteLine("Томаты\t20крон"); Console.WriteLine("Сливы\t18крон"); Console.WriteLine("\"Спасибо за покупку!\", сказала я."); }}


19

Задание 3:

Основываясь на теорию (см. [Приложение 2], стр. 35), написать программу, в которой

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


using System;

class Constanta3{ public static void Main(){ Console.WriteLine(@"Это буквальный строковый литерал.1 2 3 45 6 7 8"); Console.WriteLine( @"Отзыв о программе: ""Мне нравится C#.""");

}}


Урок 7, 8.Тема: Управляющие конструкции

Цель: Дать характеристику понятия управляющие конструкции. Познакомить со

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

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

Ход урока:

1. Объяснение нового материала, опираясь на теорию (см.[8], стр. 60-66).

2. Подробное объяснение работы программ.

20

3. Практическое применение усвоенных знаний. Используя наглядно рассмотренные

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

Задание 1:

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

экран.


using System;

class Urok3{ static void Main(){ Console.WriteLine("Введите число:"); int k = Int32.Parse(Console.ReadLine()); Console.WriteLine("Вы ввели число " + k); }}


Задание 2:

Напишите программу, считывающую с клавиатуры целое число, и выводящую на экран

квадрат этого числа.


using System;

class Urok3{ static void Main(){ Console.WriteLine("Введите число:"); int k = Int32.Parse(Console.ReadLine()); Console.WriteLine("Квадрат введенного числа " + k*k); }}

21


Урок 9, 10.Тема: Массивы

Цель: Познакомиться с понятием массив как теоретически, так и практически.

Рассмотреть виды массивов и разобрать применение их в программировании. Подготовка

к контрольной работе.

Ход урока:

1. Объяснение нового материала (см.[9], стр. 67-71).

1) Дать определение таким понятиям как массив, индексы, размерность массива и

динамический массив.

2) Теоретическое знакомство с одномерными, многомерными и рваными

массивами.

2. Практическое применение массива на Примере 1.

Пример 1.

Демонстрация использования одномерного массива. Эта программа помещает в массив

sample числа от 0 до 9.


using System;

class Array{ public static void Main(){ int[]sample = new int[10] ; //Объявление массива int i; for(i = 0; i< 10; i = i+1) sample [i]= i;

for(i = 0; i < 10; i = i+1) Console.WriteLine("sample[" + i + "]:" + sample[i]); }}


22

3. Приобретение навыков работы с массивами путем самостоятельного выполнения

практических заданий.

Задание 1:

Создание одномерного массива: Напишите программу, в которой создается массив

строк с именем names, и его элементы инициализируются цифрами «0», «1», «2». А

затем эти цифры выводятся на экран.


using System;

class Name{ public static void Main(){ int[]names = new int[3] ; //Объявление массива int i; for(i = 0; i< 3; i = i+1) names [i]= i;

for(i = 0; i < 3; i = i+1) Console.WriteLine("names[" + i + "]:" + names[i]); }}


23

Урок 11, 12.Тема: Массивы

Цель: Проверить степень овладения учениками знаний по прошедшим темам, а именно,

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

создавать самостоятельно различные программы на языке C#.

Ход урока:

1. Повторение изученного ранее материала. Ответы на возникшие вопросы.

2. Проверка полученных знаний и навыков работы при помощи проведения

контрольной работы.

Задание 1.

Создать рваный двумерный массив.


24

using System;

class Jagged{ public static void Main(){ int [][] jagged = new int [3][]; jagged[0] = new int[4]; jagged[1] = new int[3]; jagged[2] = new int[5];

int i;

// Сохраняем значения в первом массиве. for(i = 0; i < 4; i++) jagged [0][i]= i;

// Сохраняем значения во втором массиве. for(i = 0; i < 3; i++) jagged [1][i]= i;

// Сохраняем значения в третьем массиве. for(i = 0; i < 5; i++) jagged [2][i]= i;

//Отображаем значения первого массива. for(i = 0; i < 4; i++) Console.Write(jagged[0][i] + " ");

Console.WriteLine();

25

//Отображаем значения второго массива. for(i = 0; i < 3; i++) Console.Write(jagged[1][i] + " ");

Console.WriteLine(); //Отображаем значения третьего массива. for(i = 0; i < 5; i++) Console.Write(jagged[2][i] + " "); Console.WriteLine(); }}


26

Контрольная работа.

Задание 1.

Отобразить таблицу результатов возведения ряда чисел значениями от 1 до 9 в квадрат

и куб.


using System;

class Options{ public static void Main(){ int i;

Console.WriteLine("Число\tКвадрат\tКуб"); for (i = 1; i < 10; i++) Console.WriteLine("{0}\t{1}\t{2}", i, i*i, i*i*i); }}


27

Задание 2.

Написать программу, которая заполняет двумерный массив числами от 1 до 12, а затем

отображает содержимое этого массива.


using System;

class TwoArray{ public static void Main(){ int t, i; int[,] table = new int[3,4] ; //Объявление двумерного массива //размером 3 на 4 с именем table for(t = 0; t < 3; ++t) { for(i = 0; i < 4; ++i) { table[t,i]= (t*4)+i+1; Console.Write(table[t,i] + " "); } Console.WriteLine(); } }}


28

Урок 13, 14.Тема: Классы.

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

Ход урока:

1. Объяснение новой темы (см.[10], стр. 72-80). Теоретическое знакомство с

понятиями: класс, члены класса, модификатор доступа.

2. Практическое применение класса, показанное на простейшем примере и

дальнейшее подробное объяснения работы этой программы (см.[10], стр. 74-75).

3. Используя наглядно рассмотренный пример, выполнить задания (первое задание

выполняется с помощью учителя, а второе - самостоятельно):

Задание 1.

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

этажей, количество жильцов и общая площадь.


using System;

class Building { public int floors; // количество этажей public int area; // общая площадь основания здания public int occupants; // количество жильцов} // Этот класс объявляет объект типа Building.class BuildingDemo { public static void Main(){ Building house = new Building(); //создание объекта //типа Building.

int areaPP; // площадь, приходящаяся на одного жильца.

// Присваиваем значения полям в объекте house. house.occupants = 4; house.area = 760; house.floors = 2;

29

// Вычисляем площадь,приходящуюся на одного жильца дома. areaPP = house.area / house.occupants; Console.WriteLine( "Дом имеет:\n " + house.floors + " этажа\n " + house.occupants + " жильца\n " + house.area + " квадратных метров общей площади, из них\n " + areaPP + " приходится на одного человека");

}}


Задание 2.

На основе предыдущего примера, создать программу, которая создает два объекта

класса Building – Дом и Офис. И в результате выпечатывает информацию о количестве

этажей и жильцов, общей площади и сколько площади приходится на одного человека в

доме и офисе соответственно.


// Эта программа создает два объекта класса Building.

using System;

class Building { public int floors; // количество этажей public int area; // общая площадь основания здания public int occupants; // количество жильцов} // Этот класс объявляет два объекта типа Building.class BuildingDemo { public static void Main(){ Building house = new Building(); Building office = new Building();

int areaPP; // Площадь, приходящаяся на одного жильца.

30

// Присваиваем значения полям в объекте house. house.occupants = 4; house.area = 760; house.floors = 2;

// Присваиваем значения полям в объекте office. office.occupants = 25; office.area = 1400; office.floors = 3;

// Вычисляем площадь,приходящуюся на одного жильца дома. areaPP = house.area / house.occupants; Console.WriteLine( "Дом имеет:\n " + house.floors + " этажа\n " + house.occupants + " жильца\n " + house.area + " квадратных метров общей площади, из них\n " + areaPP + " приходится на одного человека");

Console.WriteLine(); // Вычисляем площадь,приходящуюся на одного работника офиса. areaPP = office.area / office.occupants; Console.WriteLine("Офис имеет:\n " + office.floors + " этажа\n " + office.occupants + " работников\n " + office.area + " квадратных метров общей площади, из них\n " + areaPP + " приходится на одного человека");

}}


31

Урок 15, 16.Тема: Классы. Конструкторы классов.

Цель: Продолжение темы Класс, более основательное знакомство с его членами.

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

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

Ход урока:

1. Продолжение изучения классов. Объяснение новой темы (см.[10], стр. 75-80).

1) Знакомство с понятием конструктор класса, рассмотрение и трактовка

примера с использованием конструктора (см.[10], стр. 75-76).

2) Член класса – поле, его определение, рассмотрение наглядного примера

(см.[10],стр.77-78). Работу программы проверяем на практике.

3) Определение метода, варианты для возвращения из метода.

4) Свойства.

2. Приложение: Использование пробелов и круглых скобок (для более правильного

программирования на языке C#).

3. Практическая групповая работа. Программирование на языке С#, используя ранее

полученные знания.

32

Групповая работа.

Ученики делятся на группы по 2 человека и выполняют задания.

Задание 1.

Напишите программу, в которой: имеется класс с именем Triangle (треугольник) и

полями (сторонами треугольника) a, b, c (типа int). Модификатор доступа у всех полей –

public. В методе main класса urok4 программа должна создать экземпляр класса Triangle,

считать с клавиатуры 3 числа, присвоить их полям a, b и c, данному экземпляру и

вывести их на экран.


using System;

class Urok4{ static void Main(){ Triangle treug; treug = new Triangle(); Console.WriteLine("Введите длинну первой стороны:"); treug.a = Int32.Parse(Console.ReadLine()); Console.WriteLine("Введите длинну второй стороны:"); treug.b = Int32.Parse(Console.ReadLine()); Console.WriteLine("Введите длинну третей стороны:"); treug.c = Int32.Parse(Console.ReadLine()); Console.WriteLine("Длины сторон треугольника следующии: " + treug.a + ", " + treug.b + " и " + treug.c); }}class Triangle{ public int a, b, c;}


33

Задание 2.

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

данный треугольник прямоугольным (возвращаемое значение bool). Используйте этот

метод для вывода на экран о сообщении, является ли треугольник прямоугольным.


using System;

class Urok4{ static void Main(){ Triangle treug; treug = new Triangle(); Console.WriteLine("Введите длинну первой стороны:"); treug.a = Int32.Parse(Console.ReadLine()); Console.WriteLine("Введите длинну второй стороны:"); treug.b = Int32.Parse(Console.ReadLine()); Console.WriteLine("Введите длинну третей стороны:"); treug.c = Int32.Parse(Console.ReadLine()); if (treug.pramoug()) Console.WriteLine("Данный треугольник является прямоугольным"); else Console.WriteLine("Данный треугольник не является прямоугольным"); }}

class Triangle{ public int a, b, c; public bool pramoug(){ if (c*c == a*a + b*b) return true; else return false; }}


34

Задание 3.

Напишите программу, вычисляющую периметр и площадь квадрата, по его стороне,

введенной с клавиатуры. Используйте класс с полем a (int) и методами, вычисляющими и

возвращающими значениями периметра и площади. И выводящую их на экран.


using System;

class Urok4{ static void Main(){ Kvadrat kv; kv = new Kvadrat(); Console.WriteLine("Введите длинну стороны квадрата:"); kv.a = Int32.Parse(Console.ReadLine()); Console.WriteLine("Периметр квадрата: " + kv.perimetr()); Console.WriteLine("Площадь квадрата: " + kv.plosad()); }}

class Kvadrat{ public int a; public int perimetr(){ return 4*a; } public int plosad(){ return a*a; }}


35

Приложение 1.

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

символов в одинарные кавычки, помимо печатных символов есть такие, которые создают

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

управляющих последовательностей символов (ESC-последовательностей), перечисленных

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

они представляют.

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

ESC-

последовательность

Описание

\a Звуковой сигнал (звонок)\b Возврат на одну позицию\f Подача страницы (для перехода к началу следующей

страницы)\n Новая строка\r Возврат каретки\t Горизонтальная табуляция\v Вертикальная табуляция\0 Нуль – символ\` Одинарная кавычка (апостроф)\" Двойная кавычка\\ Обратная косая черта

36

Приложение 2. Помимо строкового литерала можно также определить буквальный строковый

литерал. Он начинается с символа @, за которым следует строка, заключенная в кавычки.

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

может занимать две или более строки. Таким образом, можно переходить на новую строку,

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

последовательностей. Единственное исключение составляет двойная кавычка ("). Чтобы

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

необходимо использовать две подряд двойные кавычки ("").

Важно отметить, что буквальные строковые литералы отображаются точно так, как они

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

отображены на экране. Но в случае многострочного вывода переход на следующую строку

нарушит систему формирования отступов в программе.

37

Анализ учебного материала

Учебник программирования на языке C#

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

Сам по себе язык очень большой, а библиотека классов C# еще больше. И чтобы

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

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

недостаточно. По этому, было решено создать такой учебник, который смог бы

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

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

Для работы с этой книгой опыта программирования не требуется. Если вы уже знакомы

с С++ или Java, то с освоением C# проблем возникнуть не должно, поскольку у C# много

общего с этими языками. Если вы не считаете себя опытным программистом, учебник

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

приведенных как в теории, так и в практике.

Проведение анализа

Чтобы выявить сильные и слабые стороны этого учебника, я решила проанализировать

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

получила следующие результаты. В роли «испытуемых» были девушка и молодой человек

одинакового возраста, но с разными познаниями в области программирования. Разный

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

делать сравнения. А во-вторых, в реальной жизни на уроках занимаются вместе ученики

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

практика показывает, что при прохождении нового материала, это касается и

информатики, некоторые ученики схватывают все на лету, в то время как другие – заметно

отстают и замедляют процесс объяснения материала учителем. И на моем анализе, мы

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

Проработка материала, использованного в учебнике

Итак, вернемся к исследованию. Знания девушки в области программировании были

весьма незначительными: когда - то изучала язык Pascal, об остальных языках

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

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

глав вопросов не возникло. Дальнейшее изучение учебника происходило с моей помощью.

38

Совместно был рассмотрен и разобран простейший пример "Hello, world" и его скрипт.

Далее, на практике было показано, как сохранить этот текст в файл hello.cs и

скомпилировать командой csc hello.cs. После этого программа была запущена, и мы

получили следующий результат: "hello, world".

После наглядного примера, ход работы был более понятен. И самостоятельно без ошибок

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

надпись «I like C# Programming».

Четвертая, пятая и шестая глава изучалась самостоятельно. Затем на практике

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

заданий (см. [Урок 3,4], задание 1). Выполнения задания происходило индивидуально, с

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

Была проблема в инициализации переменной sum, обозначение которой предоставлено

ниже:

… sum = 0; //инициализация переменной sum…

Также был пропущен цикл for и его управляющая переменная x:

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

В итоге программа выдавала ошибку:

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

запуск программы прошли безошибочно.

Седьмая глава небольшая и требует конкретного объяснения со стороны учителя при

помощи вспомогательного дополнительного материала (в нашем случае объяснения

39

проводила я). Выполняя практические задание (см. [Урок 5,6], задание 1) трудностей не

возникло.

Сложной для понимания (теоретически и практически) оказалась восьмая глава. При

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

При ознакомлении с девятой главой «Массивы», возник интерес к данной теме. Было

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

с действительно интересным содержанием, а может с тем, что с каждой прошедшей темой

материал становился все более понятным и доступным, несмотря на усложненность

содержания. С моей помощью было разобрано различие между одномерными и

многомерными массивами, рассмотрены примеры. На основе пройденного теоретического

материала была проведена практическая работа с выполнение практического задания

(см. [Урок 9,10], задание 1). Опираясь на разобранный пример, выполнения аналогичной

программы было легко. Немного сложнее оказалось изучение рваных массивов.

Выполнение практического задания (см. [Урок 11,12], задание 1) происходило с помощью

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

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

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

Так как значения в первом, втором и третьем массиве не были обозначены и сохранены,

мы получили массив без значений. Необходимо было добавить в скрипт (сохранения

значений во втором и третьем массиве почти аналогичное):

…// Сохраняем значения в первом массиве. for(i = 0; i < 4; i++) jagged [0][i]= i;…После исправления ошибки результат выполнения программы был следующий:

40

Изучение десятой главы привело к знакомству с фундаментом, на котором построен

язык C# – с классом. Теоретический материал не представлял особых трудностей. Очень

подробно приведено определение класса, его роль. Вполне понятно расписан пример

класса (см. [10], стр.74). В данном примере не только определен скрипт программы, но

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

подробно расписано и объяснено каждое действие, что является хорошим помощником

при разборе новой темы. После небольшого теоретического знакомства с классами,

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

материала выполнить задание (см. [Урок 13,14], задание 1). С моей помощью был создан

скрипт и запущена данная программа. Задание оказалось не из легких и без посторонней

помощи ученику не обойтись. Следующее задание (см. [Урок 13,14], задание 2),

основанное на предыдущем, но с некоторыми добавлениями, было выполнено

самостоятельно. Дальнейшее знакомство с классами – конструкторы классов, поля,

методы, свойства были рассмотрены вместе со мной.

Что касается изучения учебника по программированию на языке C# молодым

человеком, то здесь процесс протекал намного быстрее. Молодой человек был немного

знаком с такими языками программирования как Java, C, C++ и поэтому с освоением C#

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

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

C, C++ и тесно связан с неменее успешным языком Java. У C# и Java не говоря о

множестве общих черт, некоторые ключевые слова совпадают, например, new, bool, this,

break, static, class, throw, virtual и null. Можно много найти сходств, поэтому молодому

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

ней примеры написания программ, и он смог почти безошибочно выполнять

предоставленные мною практические задания. Вопросы возникли при компилировании

программ, так как в C# другой компилятор.

Подведение итогов, выявление плюсов и минусов

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

«Язык программирования C#» должен помочь учителям проводить уроки

программирования, а ученику – научиться программировать на языке C#. Теоретическая

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

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

были проверены непосредственно с текста книги, где они напечатаны в виде, пригодном

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

41

эффективным, я также пыталась, где это, возможно, проиллюстрировать полезные

алгоритмы и принципы хорошего стиля и разумной разработки.

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

ность каждому ученику самостоятельно решить поставленную им задачу. Если ученик не

может действовать полностью самостоятельно, то он получает помощь преподавателя

именно в таком объеме, который достаточен для перехода к самостоятельным действиям.

В ходе проведенной работы были выявлены и минусы учебного пособия:

Данный учебник представляет лишь часть того, чем богат язык программирования

C#, поэтому заинтересовавшемуся в дальнейшем изучении этого языка человеку

необходимо использовать дополнительную литературу.

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

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

же заданий будет не очень интересно.

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

сложно при возникновении ошибок исправить их самим.

Есть главы, где теоретическая часть довольно сжата и при самостоятельном

обучении могут возникнуть вопросы.

Способ проведения уроков программирования

Я уже упоминала, что в школах обычно уроки проводятся в классах с разным уровнем

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

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

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

Исходя из этого, я решила, что при изучении этой темы лучшим вариантом было бы

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

второй – послабее. Это не должно вызвать проблем, так как 12 класс – выпускной, и

учащиеся таких классов уже профориентированы. Причем круг выбранных ими

профессий предполагает использование компьютера.

Первой группе можно было бы давать учебного материала в большем размере, и

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

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

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

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

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

42

программных средств. Наоборот, их привлекают созданные на высоком профессиональном

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

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

обращать особое внимание на возникшие в результате работы ошибки и предотвращать их

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

результатов. Следует заметить, что в этом случае и эффективность труда учителя

возрастает без увеличения его нагрузки, что немаловажно в наше время.

По моему мнению, такой подход к обучению более обеспечен на успех. Облегчая

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

программирования и делает этот процесс интересным и более простым. При грамотном

применении этого подхода в учебном процессе, есть вероятность повышения уровня

образования в области программирования.

43

Заключение В заключение, хотелось бы сказать, что теперь вы имеете представление о C# – языке

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

смею вас уверить – далеко не всех. Надеюсь, к этому моменту вы уже обладаете желанием

использовать C# в своих разработках. Созданное учебное пособие было бы неплохим

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

По моему опыту, язык программирования C# показал себя приятным, выразительным и

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

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

44

Использованная литература1. Герберт Шилдт. Полный справочник по С#, Москва, 2006.

2. Все о программировании C#, http://www.c-sharp.ru/ (20.08.2006).

3. Основы C#, http://podgoretsky.com/ftp/Docs/CSharp/CSharpBasis/ (12.09.2006).

4. Программирование: C# – типы данных, http://gazette.linux.ru.net/lg85/ortiz.html

(2.10.2006).

5. Учебник по C#, http://www.dotsite.spb.ru/Tutorials/CSharp/ (10.10.2006).

45

http://www.dotsite.spb.ru/Tutorials/CSharp/

http://gazette.linux.ru.net/lg85/ortiz.html

http://podgoretsky.com/ftp/Docs/CSharp/CSharpBasis/

http://www.c-sharp.ru/

Краткое описание работы на эстонском языке

Lühikirjeldus eesti keeles C# on uus, kasaaegne keel, millel on palju võimalusi. Lähtudes sellest, et C# on üks viimase

aja levinumaid programmeerimiskeeli, peab ta sisaldama paremaid külgi erinevatest keeltest ja

omandatud kogemustest.

Ma koostasin õpiku, nimega „Programmeerimiskeel C#”. Minu õpik on mõeldud

kaheteistkümnenda klassi õpilastele ning selle eesmärgiks C# keeles programmeerimise

õpetamine. Õpikut on püütud kirjutada arusaadavas keeles. Õpik on kaheosaline, ning hõlmab

teooriat ja praktikat. Teoreetilises osas on antud õppematerial koos näidistega. Praktilises osas on

ülesandeid (ülesanded koos programmiga ja kontrolltööd) iseseisvaks tööks. Samuti oli

eesmärgiks anda uutele kasutajatele lihtsam programeerimisvõimalus. See raamat on ette nähtud

edasijõudnutele.

Käesolev õpik on sissejuhatav kursus programmeerimisse. See annab teadmised

programmeerimise põhimõistetest, sellised nagu muutujad, andmete liigid, massivid, klassid.

Seda enam, et ka algaja peab suutma iseseisvalt omandada programmeerimiskeelt. Kuigi

sealjuures tuleks kasuks kogenud kolleegi abi. Praegusel juhul eeldan et selleks on kooli

arvutiõpetaja.

Antud õpik ei ole ammendav material C# keele õppimiseks. Keele valdamise taseme ja

meisterlikkuse taseme tõstmiseks on vaja kasutada ka teised allikad. Kahtlemata suureneb seoses

keele populaarsuse kasvuga ka õpikute hulk.

Töö ülesehitus

Algselt oli õpematerial mõeldud abistamaks õpilast programmeerima C# keeles. Seal on

sissejuhatus, eraldi peatükid kõigi põhiliste keele iseärasuste kohta ja praktilise kasutamise

näited. Õpetamine on üles ehitatud peamiselt lugemisele, kirjutamisele ja näidiste arutelule, mitte

aga ainult reeglite õppimisele. Õpikus toodud näited on suures osas lõpetatud reaalsete

programmidega. Peale selle koostasin ma tunnikonspekti C# keele õpitamiseks.

Teoreetiline osa on jaotatud 11 osaks:

1) Üldine C# keele kirjeldus

2) Mis tähendab NET Runtime?

3) C# rakendamine

4) C# andmetüübid

5) Muutujad

6) Оperaatorid

46

7) Konstandid

8) Tingimuslaused

9) Massiivid

10) Klassid

11) Töö konsooliga

Esimine osa sisaldab C# programeerimiskeele üldist kirjeldust ja eesmärke.

Teises osas on NET Runtime üksikasjalik kirjeldus, kus täidetakse programmi

kompileerimisel saadud kood.

Kolmandas osas vaadeldakse C# kasutamise praktilisi aspekte. Kõige lihtsama näite alusel

vaadeldakse programmi loomist ja kompileerimist, samuti on põhjalikult seletatud programmi

iga rea tähendus.

Neljas osa on tähtis ja mahukas. Tema nimetus on “Andmete liigid”. Seal vaadeldakse

järgmisi küsimusi:

• Millised võivad olla andetüübid.

• Millisteks gruppideks jagunevad andmetüübid.

Selleks, et materjal oleks nähtav ja kättesaadav, me konstrueerisime tabeleid.

Viies paragrahv esitleb muutujaid; mis võivad olla staatilised, eksemplaarsed ja lokaalsed.

Edasi tutvume operaatorite laia valikuga, mis annab programmeerijatele võimalusterohked

juhtimisvahendid mitmesuguseid väljandite loomiseks ja nende väljaarvutamiseks.

Seitsmendaks teemaks on klassi juurde kuuluvad konstandid.

Tingimuslaused (8 osa) on suur ja tähtis teema. Seal ma käsitlesin erinevaid operatoreid nagu

IF, SWITCH, IF...ELSE, FOR, FOREACH, WHILE ja DO-WHILE, GOTO. Ma andis neile

definitsioone ja üksikasjalikke selgitusi. Selleks, et need operaatorid oleksid rohkem

kättesaadavad, tõin ma esile erinevaid näiteid.

Järgmine tähtis teema on massiiv. Seal on massiivi definitsioon, erinevad massiivide liigid ja

näited kuidas nendega töötada.

Eelviimases osas on defineeritud klassid. Klassis on 2 suurt osa – mooduli ja andmetetüüpide

osa. Samuti võib peale põhimõistate selles peatükis näha näite klassi käivitunud programmidega

töö näitlikuks ülevaatleks. Tutvume mõistetega – klassi konstruktorid, väljad, meetodid,

omadused ja nende tähtsusega.

Viimases peatükis on abistav materjal, kus kirjeldatakse konsooliga töötamise reeglid.

Praktiline osa kujutab endast metoodilist materjal, mis koostab 16 tunnist. Kõigis tundides on

peaaegu üks sarnane skeem – alguses käsitletakse teoreetilise materjali koos näidistega, ja

47

seejärel toimub teadmiste kontroll individuaalsete praktiliste ülesannete lahendamise abil.

Samuti on selles osas kahest ülesandest koosnev kontrolltöö omandatud oskuste kontrollimiseks.

Õppekava

Meie ajal areneb infrostruktuur kiiresti, ning lastel tekib rohkem kogemusi tööks arvutiga.

Need programmid mis paar aastat tagasi ei olnud nii levinud, on täna kõigile kätte saadavad.

Põhiliste programmidega nagu tekstitöötluse, tabeltöötluse ja esitlusprogrammidega hakkavad

lapsed töötama juba kolmandas või neljandas klassis, ning gümnaasiumi astumise ajaks valdavad

nad neid programme piisavalt hästi. Ent tänapäeval vanemate klassi informatika õppekavasse

juba sisse viidud erinevad programmeerimiskeeled. Ma arvan, et 12. (kaheteistkümnendas)

klassis on ka võimalik sisse viia C# programeerimiskeel.

Materjal on mõeldud ühe kursuse jaoks. Kursus kestab kümme nädalat ja ta on jaotatud 20

tunniks. Tund toimub üks kord nädalas ja see on paaristunni kaupa (45 + 45 minuti).

Praktiline C# rakendamine

Tund algab teema määratlemisest ja konkreetse sihi püstitamisest, mis tuleb ellu viia. Edasi

on kirjeldatud tunni käiku ja esitatud ülesandeid iseseisvaks tööks. Erilist tähelepanu

pühendatakse selgituste lühidusele, kuid samal ajal maksimaalsele teadmiste saamise

võimalusele nii õpetajatele, kes hakkavad antud materjali põhjal õpetama, nii ka õpilastele, kes

hakkavad seda õppima. Samuti on omandatud oskuse kontrolliks kontrolltöö, mis koosneb kahest

ülesandest. Praktilise materjali lõpus on kaks lisa, mida õpilased saavad kasutada tunni käigus.

Õppematerjali analüüs

Analüüsi tegemine

Et selle õpikute tugevad ja nõrgad küljed ilmutada, ma otsustasin analüüsida kahe inimese

tööd õpematerjaliga. Proovirolliks oli neiu ja noormees ühe vanusega, kuna erinevate oskustega

programmeerimises. Erinev arengutase oli tarvilik. Esimeseks: selle alusel on kergem ja

mõistlikum võrdlus teha. Teiseks: reaalses elus tunnis õpetatakse koos tugevaid ning nõrku

õpilasi. Kahjuks, praktika näitab, et uut materjali läbi võttes, see käib ka informaatikast, mõned

õpilased saavad kõik aru, samal ajal teised – jäävad maha ja aeglustavad õppeprotsessi. Minu

analüüsis ma püüan niisuguse õpetuse eelised ja puudused välja selgitada.

Nõrgad ja tugevad küljed

Uurimise lõppedes võib öelda, et koostatud programmeerimiskeele C# õppematerjal abistab

õpetajatele programmeerimise tunni korraldada, aga õpilastel – õppida C# keeles

48

programmeerida. Teoreetiline osa on hea abiline tutvumiseks antud keelega, aga praktiline osa

abistab saadud teadmisi kontrollida ja kindlustada.

Tuleb märkida, et õppekava selles õppematerjalis annab võimalusi iga õpilastele iseseisvalt

lahendada enesele püstitatud ülesannet. Kui õpilane ei saa töötada iseseisvalt, siis ta saab

arvutiõpetaja aidata selles ulatuses, millest on piisavalt ülemineku jaoks iseseisvaks tegevuseks.

Oma töö analüüsimisel oli leitud ka nõrgad küljed:

Antud õpik esitab C# programmeerimiskeelest vaid osa. See tähendab kui te tahate seda

keelte edasi õppida, siis teil on vaja lisaks kirjandust kasutada.

Võimalik, et andekatele õpilastele programm osutub lihtsaks, sest töö on ettenähtud

kesktaseme õpilastele. Aga nõrgal õpilastel nii kiire teooria ja praktika omandamine on

raske.

Praktilised ülesanded on tarvis täita õpetaja abiga. Sest vea tekkimise puhul on raske neid

parandama iseseisvalt.

Kokkuvõte

Kokkuvõteks tahaks öelda, et nüüd on teil ettekujutus C# – järgmise põlvkonna keelest. Antud

töös räägitakse selle paljudest võimalustest, kuid julgenud teile kinnitada, et sugugi mitte kõigist.

Loodan, et nüüd on teil tekkinud soov kasutada keelt oma töös. Käesolev õpik oleks heaks

aluseks antud programmeerimiskeele õppimisel.

Minu kogemus näitab, et programmeerimiskeel C# on osutunud meeldivaks, väljandusrikkaks

ja mitmekülgseks keeleks paljute erinevate keelte seas. Ma loodan, et see õpik aitab teil seda

keelt hästi omandada.

49

Учебный материал начального курса языка C#

1. Общее описание языка C# C# (произносится Си-Шарп) – это новый язык программирования от компании

Microsoft. Он входит в новую версию Visual Studio – Microsoft Visual Studio.NET (ранее

называлась Visual Studio 7). Кроме C# в Visual Studio.NET входят Visual Basic.NET и Visual

C++. Microsoft описывает C# как «простой , современный, объектно-ориентированный и

безопасный язык программирования, наследник С и С++». Все эти языки обеспечивают

доступ к платформе Microsoft .NET (ранее эта платформа называлась Next Generation

Windows Services NGWS), которая содержит общее исполняющее ядро и обширную

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

Common Language Subset (CLS, также называется Common Language Specification),

который обеспечивает взаимодействие между всеми языками и библиотекой классов. Для

разработчиков это означает, что C# будет иметь доступ ко всем средствам, знакомым

разработчикам на Visual Basic и Visual C++.

Одна из причин разработки нового языка компанией Microsoft – это создание

компонентно-ориентированного языка для новой платформы .NET. Другие языки были

созданы до появления платформы .NET (произносится "дотнет"), язык же C# создавался

специально под эту платформу. Еще одна из причин разработки компанией Microsoft

нового языка программирования – это создание альтернативы языку Java. Что будет с Java

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

ясно, что одна из целей разработки C# – это противоборство именно с Java (недаром C#

называют еще Java-killer'ом). Многие разработчики хотели бы использовать современный

язык, который позволял бы писать, читать и сопровождать программы с простотой Visual

Basic и в то же время давал мощь и гибкость C++, обеспечивал доступ ко всем

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

программами и легко работал с возникающими Web стандартами. Учитывая все подобные

пожелания, Microsoft разработала язык – C#, в который входит много полезных

особенностей – простота, объектная ориентированность, типовая защищенность, "сборка

мусора", поддержка совместимости версий и многое другое.

При создании C#, его авторы учитывали достижения многих других языков

программирования: C++, C, Java, SmallTalk, Delphi, Visual Basic и так далее. Надо

заметить, что по причине того, что C# разрабатывался с чистого листа, у его авторов была

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

предшествующих ему языков.

50

2. Что такое NET Runtime? Если перевести слова NET Runtime на русский язык, то мы получим что-то вроде

"Среда выполнения". Именно в этой среде и выполняется код, получаемый в результате

компиляции программы написанной на C#. Теоретически программа для среды NET

Runtime может выполняться под любой операционной системой, в которой NET Runtime

установлена. Но на практике пока единственная платформа для этого – это Windows.

NET Runtime состоит из нескольких частей. Одна из них – это Common Language

Runtime. Говоря кратко, это некоторый набор стандартов, которые должны поддерживать

все языки платформы .NET. Например, в предыдущих версиях Visual Studio была такая

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

тип целого в Visual Basic'е занимал два байта, а в Visual C++ – четыре. А это порождало

кучу проблем при совместном использовании языков. Так вот, Common Language Runtime,

как раз в частности и определяет стандартные для всех языков .NET типы данных. И уже

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

одноименному типу в другом.

Еще одна важная часть NET Runtime – это набор базовых классов. Их очень много

(порядка несколько тысяч). Кроме того, эти классы относятся не к конкретному языку, а к

NET Runtime. То есть мы получаем набор классов, общий для всех языков .NET, что

достаточно удобно.

Именно NET Runtime берет на себя некоторые рутинные функции. Например, в нем

организована сборка мусора. И если раньше программисту приходилось самому

освобождать объекты, созданные динамически, то теперь эту задачу берет на себя среда

NET Runtime. Еще одно свойство среды NET Runtime – это проверка типов. Это означает,

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

параметр неправильного типа. Например, вместо целого, подставить действительное

число. Языки типа C++ свои параметры функций не проверяют, в результате чего,

записанная переменная большего размера может повредить чужую область памяти, и

программа может просто рухнуть. Еще классический пример на эту тему – это выход за

пределы массива. В NET Runtime же такого невозможно. NET Runtime сама позаботится о

проверке типов и других вещах.

Существует несколько языков для NET Runtime. В настоящее время это C#, VB.NET и

Visual C++. Кроме того, фирма Borland объявила, что ее продукты C++ Builder и Delphi

тоже будут поддерживать NET Runtime.

51

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

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

написав программу, выводящую на экран фразу «Hello, world». Начнем с компиляции:

Переходя к более подробному знакомству с C#, традиционно рассмотрим программу

"Hello, world":

using System;

class Hello{ static void Main(){ Console.WriteLine("Hello, world"); }}

Сохраните этот текст в файл hello.cs и скомпилируйте ее командой:

csc hello.cs

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

вас прописан путь csc.exe – C Sharp Compiler. В результате вы получите файл hello.exe,

запустив который, вы увидите надпись:

"hello, world".

Давайте подробно рассмотрим каждую строку этой программы.

Using System указывает на то, что мы обращаемся к пространству имен (namespace) System,

предоставляемому ядром Microsoft .NET. Это пространство имен содержит класс Console,

используемый в методе Main(). Метод Main – это точка входа в программу, с него

начинается выполнение. Этот метод обязательно должен быть статическим членом класса

Hello. Как мы отметили выше, глобальных переменных в языке не существует —

переменные и функции всегда объявляются внутри объявлений классов или структур.

Пространства имен служат для логической организации элементов библиотеки классов.

Директива using позволяет использовать члены пространства имен более простым

52

образом. Так, ниже мы используем вызов Console.WriteLine, который является

сокращенным вариантом вызова System.Console.WriteLine.

Отметим, что эта концепция схожа с директивой Use в языке Object Pascal.

Строка «Hello, world» выводится на экран методом WriteLine класса Console. Здесь мы

используем единую библиотеку классов, доступную из C#, Visual Basic и Visual C++. Язык

C# не имеет собственной библиотеки классов.

Вы можете также создавать библиотеки классов – dll-сборки, которые могут

использоваться другими приложениями. Для этого нужно указать /target:library в опциях

компилятора

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

сообщение и остановит процесс компиляции. Также он может выдать предупреждения –

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

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

53

4. Типы данных в С# Прежде чем разговаривать о том, как работать с данными на C#, нужно поговорить о

том, какие это могут быть данные.

Типы данных имеют в C# особое значение, поскольку C# – строго типизированный

язык. Это значит, что все операции проверяются компилятором на соответствие типов.

Некорректные операции не компилируются. Таким образом, контроль типов способствует

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

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

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

значения определяет, какие операции разрешено выполнять с таким значением. Операция,

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

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

числовые типы (которые, в свою очередь делятся на целые, вещественные и тип decimal) и

булевый тип.

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

То есть, значения типа структура передаются по значению, а не по ссылке. Есть и другие

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

Переменные типа перечисления могут принимать одно из заданных (перечисленных)

значений. Значения задаются при определении типа. Также бывают битовые перечисления,

в которых значения могут комбинироваться.

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

C# содержит две категории встроенных типов данных: типы значений и ссылочные

типы. Ссылочные типы определяются в классах, но о классах речь еще впереди. Ядро

языка C# составляют 13 типов, перечисленных в таблице ниже. Это – встроенные типы,

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

C# - программе. Термин «тип значения» применяется к переменным, которые

непосредственно содержат значения. (Для сравнения: переменные ссылочных типов

содержат ссылки на реальные значения.) Типы значений также называют простыми

типами.

54

Типы значений: Ключевое слово ТипBool Логический или булев. Представляет

значения ИСТИНА/ЛОЖЬByte 8-разрядный целочисленный без знакаChar СимвольныйDecimal Числовой тип для финансовых вычисленийDouble С плавающей точкой двойной точностиFloat С плавающей точкойInt ЦелочисленныйLong Тип для представления длинного целого

числаSbute 8-разрядный целочисленный со знакомShort Тип для представления короткого целого

числаUint Целочисленный без знакаUlong Тип для представления длинного целого

числа без знакаUshort Тип для представления короткого целого

числа без знака

В C# определено девять целочисленных типов: char, byte, sbyte, int, uint, short, ushort,

long, ulong. Тип char в основном используется для представления символов, а остальные

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

Целые типы:

Тип C#

Размер в битах Диапазон Пояснение

char 16 0 – 65 535Символ (16-битный Unicode - символ ) Например: 'A' (символ в одиночных кавычках)

byte 8 0 –255 Байт (беззнаковое 8-битное число)sbyte 8 –128 – 127 Беззнаковое 8-битное целое

Int 32 –2 147 483 648 – – 2 147 483 647

Целое (со знаком) (Знаковое 32-битное число) Для записи целых чисел в тексте программы можно использовать десятичную (по-умолчанию) или шестнадцатеричную (префикс 0x) нотацию. Например: 26, 0x1A

uint 32 0 – 4 294 967 295 Беззнаковое 32-битное целоеshort 16 –32 768 – 32 767 Короткое целое (Знаковое 16-битное число)ushort 16 0 – 65 535 Беззнаковое 8-битное целое

long 64 –9 223 372 036 854 755 808 – – 9 223 372 036 854 775 807

Длинное целое (со знаком) (Знаковое 64-битное число)

ulong 64 0–18 446 744 073 709 551 615 Целое 64-битное число

55

Согласно этой таблице, в C# определены обе версии всех целочисленных типов: как

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

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

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

разряд такого значения используется в качестве флага знака (sign flag). Если флаг

знака равен нулю, то число положительно, если он равен 1, то число отрицательно.

Отрицательные числа почти всегда представляются в виде дополнения до двух. Для

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

знакового, инвертируются, а затем результат инвертирования суммируется с единицей.

Наконец, флаг знака устанавливается равным единице.

Самым популярным целочисленным типом является int. Переменные этого типа часто

используются для управления циклами, индексации массивов и в математических

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

превышает диапазон, допустимый для типа int, у вас есть несколько возможных вариантов

для выбора. Если вы не предполагаете обрабатывать отрицательные числа, можно

воспользоваться типом uint. Для работы с большими числами со знаком, возможно,

подойдет тип long, а без знака – тип ulong.

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

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

Тип C# Размер в битах Диапазон Пояснение

float 32 1,5Е – 45 до 3,4Е + 38 Вещественное число (7 знаков)double 64 5Е – 324 до 1,7Е + 308 15 – 16 знаков

Из этих двух типов наибольшей популярностью у программистов пользуется тип

double. Одной из основных причин этого является использование double-значений

множеством математических функций библиотеки классов С#. Например, метод Sqrt(),

который определен в стандартном классе System.Math, возвращает double-значения,

являющееся квадратным корнем из double-аргумента.

Логический тип

Тип C# Пояснение

bool Логический тип. Может иметь только два значения ИСТИНА/ЛОЖЬ (true или false).

56

В С# не определено ни одного преобразования значения типа bool в целочисленное значение. Например, число 1 не преобразуется в значение true, а число 0 – в значение false.

Тип decimal

Decimal описывает 128-битный числовой тип. Он может быть как целым, так и

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

сумм.

Тип C# Размер в битах Диапазон Пояснение

decimal 128 1E –28 до 7,9E + 28 Вещественное число фиксированной точности (28-39 значащих цифр).

Применение обычной арифметики с плавающей точкой к десятичным значениям

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

тип.

• Обратим внимание на то, что следующие три объявления переменной k

(переменные будут рассмотрены в следующем пункте) равносильны:…int k;using System;…

…Int32 k;…

и…System.Int32 k;…

Разумеется, аналогично мы имеем дело и другими типами языка C#.

57

5. Переменные Данные в C# хранятся в переменных соответствующего типа. C# является языком со

строгой типизацией – значит, компилятор гарантирует, что переменная всегда имеет

значение своего типа.

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

массивов, параметры, передаваемые по значению, выходные параметры и локальные

переменные. Рассмотрим определения нескольких из них:

Статическими переменными являются поля класса, объявленные с ключевым словом

static. Их значение является общим для всех экземпляров класса.

Экземплярные переменные – это поля класса, значения которых для каждого

экземпляра индивидуальны.

Локальные переменные – это переменные, объявленные в теле метода. Они не

инициализируются (задаются начальные значения) автоматически и время их жизни

зависит от компилятора, но оно не больше, чем время исполнения метода. Локальные

переменные могут быть определены и в управляющих блоках for, while, foreach, if.

58

6. Операторы Набор операторов для C# достаточно стандартен +, –, *, / – действуют, как и в любом

другом языке (арифметические операторы). Отметим только, что / (деление)

применительно к целым числам дает целую часть от деления. Так, фрагмент…int k=100999, n=1000, s;s=k/n;…Console.WriteLine(s.ToString());выведет на экран 100, а не 101, то есть никакого округления не происходит.

Есть еще один оператор – %. Это – остаток от деления. Например, 10 % 3 равно 1.

В C# оператор % можно применить как к целочисленным типам, так и типам с плавающей

точкой. Например, 10,0 % 3,0 также равно 1.

Следующий фрагмент выведет на экран 999:…int k=100999, n=1000, s;s=k%n;Console.WriteLine(s.ToString());…Как и в других C-подобных языках, в C# существуют операторы инкремента (++) и

декремента (– –). Так, после следующего фрагмента k увеличится на 1, а n – уменьшится

на 1:…k++;n--;… Итак, оператор инкремента выполняет сложение операнда с числом 1, а оператор

декремента вычитает 1 из своего операнда. Это значит, что инструкция

x = x+1;

аналогична следующей:

x = ++;

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

Операторы отношений оценивают по «двубальной системе» (ИСТИНА/ЛОЖЬ)

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

Оператор Значение Оператор Значение= = Равно < Меньше! = Не равно >= Больше или равно> Больше <= Меньше или равно Как и в других C-подобных языках, в C# существуют следующие логические

операторы:

59

Оператор Описание Пример

&& Логическое И. Результат равен true, только если оба операнда равны true (x= =8) && (y= =5)

|| Логическое ИЛИ. Результат равен false, только если оба оператора равны false (y>8) || (y<5)

! Отрицание. Изменяет логическое значение на противоположное if(!(a= =b))...

Все эти операторы возвращают результат типа bool.

Обратите внимание, что для логического оператора равно (то есть для ответа на вопрос

"Верно ли, что что-то равно чему-то") используется знак двойного равенства (= =). Знак же

одинарного равенства (=) используется для присваивания. Для знака = = существует

парный знак ! = ("не равно"). Так, приведенный выше пример для оператора ! можно

переписать так:if(!(a==b))…

Отметим, что в C#, в отличие от многих других языков программирования, нельзя вместо

false использовать 0, а вместо true – любое ненулевое число. Так, следующий фрагмент

содержит ошибку:

…int k;…if(k) //Ошибка!…

60

7. Константы Константы (литералы) в C# – это члены класса, значения которых определены в

течение всего выполнения программы и определяются еще на этапе компиляции. Это

фиксированные значения в понятной форме. Определение константы производится

посредством ключевого слова const:

…const int a = 2;…

Константы не могут определяться со словом static, но в то же время являются членами

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

конкретными значениями, так и через другие константы:

…const int a = 3;const int b = a + 7;…

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

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

–100 – это целочисленные литералы. Константы с плавающей точкой должны обязательно

иметь десятичную точку, а за ней – дробную часть числа. Примером константы с

плавающей точкой может служить число 11.123.

Язык C# поддерживает еще один тип литерала – строковый. Строка – это набор

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

"Это текст" представляет собой строку.

61

8. Управляющие конструкции

Операторы If, switch, if..else

Управляющие конструкции – это то средство, которое позволяет вам создавать

алгоритмы. Стандартными управляющими конструкциями являются: if, for, while, goto. К

тому же в C# есть существуют дополнительные конструкции: switch, do и foreach.

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

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

некоторое условие, то программа идет в одну сторону, если не выполняется – то в другую.

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

…class Class1{ static void Main(string[] args){ int k = Int32.Parse(Console.ReadLine()); if(b){ Console.WriteLine("Четное число"); } else{ Console.WriteLine("Нечетное число"); } Console.ReadLine(); }}

Как и в других C-подобных языках, фигурные скобочки можно не писать в случае одного

оператора. Также написание else тоже не является необходимым – все зависит от

конкретной задачи.

switch Данная инструкция обеспечивает многонаправленное ветвление. Она позволяет делать

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

программа должна разделиться более чем на два направления (то есть будем двигаться или

сюда, или сюда, или сюда).

Вот пример:

62

…int k = Int32.Parse(Console.ReadLine());Console.WriteLine(k.ToString());switch (k){ case 1: case 2: Console.WriteLine("Неудовлетворительно"); break; case 3: Console.WriteLine("Удовлетворительно"); break; case 4: Console.WriteLine("Хорошо"); break; case 5: Console.WriteLine("Отлично"); break; default: Console.WriteLine("Ошибка"); break; }…

В приведенном примере в зависимости от введенного пользователем числа на экран

выводится та или иная оценка. Если число k не лежит в промежутке от 1 до 5, то

выполняются операторы в веточке default и выводится надпись "Ошибка". Ветока default

не обязательна. Обратите внимание на оператор break. Если его не написать, то будут

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

примере если пользователь введет 1 или 2, то программы выведет

"Неудовлетворительно"). Обратите внимание, что если в некоторой веточке case или

default есть операторы, то написание break обязательно. Так, в следующих двух

фрагментах кода есть ошибки:

…case 1: Console.WriteLine("Совсем неудовлетворительно"); //Ошибка! Тут пропушен breakcase 2: Console.WriteLine("Неудовлетворительно"); break;… default: Console.WriteLine("..."); //Ошибка! Тут пропушен break }

if..else63

Блок if..else, как видно из названия, позволяет выполнять код при выполнении

определенного условия:…if (a > b){ Console.WriteLine("a > b");}else{ Console.WriteLine("a <= b");}…

Логическое выражение в скобках должно иметь тип bool (в отличие от C/C++, где

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

– второй. При этом если какой-либо блок команд состоит лишь из одной команды,

обрамляющие фигурные скобки можно опустить:

…If (server0bject != null) server0bject.Initialize() ;…

Циклы for и foreach.

for Чтобы многократно выполнить последовательность программных инструкций,

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

командой, условием окончания и командой перехода.

Пример:

…int k = Int32.Parse(Console.ReadLine());int sum=0;for(int i=1; i<=k; i++){ sum+=i;}Console.WriteLine(sum);…

Этот пример подсчитывает сумму чисел от 1 до введенного пользователем числа k. Сумма

записывается в переменную sum и выводится на экран. Логика выполнения цикла

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

проверяется условие окончания, если оно ложно, то цикл прекращается и управление

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

– команда перехода.

64

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

нумерация элементов массива идет с нуля, то типичный цикл будет выглядеть так:…int[] a = {-5, 4, 55};int sum=0;for(int i=0; i<3; i++){ sum+=a[i];}…В этом примере начальное значение для счетчика цикла равно нулю, и в условии

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

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

то фигурные скобки можно не писать.

foreach foreach – это очень удобный оператор, значительно облегчающий работу с

коллекциями (группа объектов) в C#. C# определяет несколько типов коллекций, и одним

из них является массив.

Наиболее общей формой использования foreach является следующая:

…int[] m = {-5, 4, 10};int sum=0;foreach(int i in m){ sum+=i;}…

В данном примере мы суммируем все элементы массива m, записывая сумму в sum.

В приведенном примере наш цикл перебирает все элементы массива m. На это нам

указывает строка:

…foreach(int i in m){…Данная строка интерпретируется так: для каждого целого числа из массива m делам что-то

там. Если бы элементами массива были бы не целые, а, скажем, вещественные, то мы

записали бы следующее:

…foreach(float i in m){…

65

То есть мы пишем именно тип элементов массива. На самом деле foreach используется не

только для массивов, но и для других объектов (например, для хэш-таблиц). Но это будет

рассмотрено в дальнейшем изучении языка C# .

Циклы while и do-while.

Циклы while бывают двух видов – собственно цикл while и do-while. Оба эти цикла

используются, как правило, тогда, когда точно не известно, сколько раз цикл должен

выполнится. Например, при вводе пользователем пароля или при подсчете чего-либо с

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

круглых скобках после слова while будет истинно. Как только условие станет равным false,

выполнение цикла прекращается. Самое важное отличие между while и do-while в том, что

while может не выполниться ни одного раза, тогда как do-while по крайней мере один раз

выполнится. Вот примеры их использования:

whileЦикл while является циклом с предусловием: сначала проверяется определенное условие перехода, а затем выполняется итерация цикла. Синтаксис цикла while в общем случае следующий:…// Задаем числоint num = 678;

// Число разрядов - 0int len = 0;

// считаем сколько разрядов в числеwhile (num > 0){ len++; num /= 10;}

Console.WriteLine(len);…

Семантика очень проста: проверяем условие перехода. Если оно истинно, то переходим к

телу цикла и затем снова к проверке условия, иначе – прекращаем выполнение цикла.

Еще один пример:

66

…string password;do{ password=Console.ReadLine();}while(password!="wi98zK");…

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

пароль (wi98zK)

do-while Оператор do реализует цикл с постусловием. В отличие от циклов for и while, в которых

условие проверяется при входе, цикл do-while проверяет условие при выходе из цикла. Это

значит, что цикл do-while всегда выполняется хотя бы один раз. Это иногда бывает

удобным.

Пример:

…int k=0; //Количество попыток//заводим новую последовательность случайных чиселRandom rnd=new Random(112); //Пишем любой параметрwhile(rnd.Next(1, 6)!=5){ k++;};Console.WriteLine("С "+(k+1).ToString()+"-го раза выпало 5");…

В этом примере цикл будет вращаться до тех пор, пока некоторое случайное число не

окажется равным 5. При этом если число с самого начала оказалось равным пяти, то цикл

вообще выполняться не будет.

Цикл goto

goto – это просто оператор безусловного перехода. Он применяется в двух ситуациях:

когда нужно перейти на обработку определенного случая в блоке switch (он будет

рассмотрен позднее) или выполнить переход в определенное место программы. Во втором

случае нужно указать метку в этом месте. Метка – это действительный в C#

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

методе с инструкцией goto, которая ссылается на нее.

Метка указывается просто – в нужном месте программы пишется имя метки с

двоеточием на конце:

67

…Exit: return 0;…

Чтобы перейти на эту метку, используется следующий синтаксис оператора goto:

…goto Exit;…

Еще goto применяется, если нужно перейти к определенной ветви в блоке switch:

…int level = GetLevel();switch (level){ case 0: Console.WriteLine("Level is less than 1"); break; case 1: goto case 2; case 2: Console.WriteLine("level is greater than or equal to 1"); goto default; default: Console.WriteLine("bye"); break;}…

Блок case x выполняется, если выражение, указанное в скобках после switch равно x. Блок

default – если ни одно из case-выражений не выполнилось. Удобно switch использовать

для обработки выражений перечислимых типов. Для переходов между блоками можно

использовать команды goto case и goto default.

68

9. Массивы Массивы в C# очень просты и несколько отличаются от других C-подобных языков.

Массив (array) задает способ организации данных. Массивом называют упорядоченную

совокупность элементов одного типа, обращение к которым происходит с использованием

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

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

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

программированию из домашней библиотеки.

Каждый элемент массива имеет индексы, определяющие порядок элементов. Индекс

описывает позицию элемента внутри массива. Число индексов характеризует размерность

массива. Каждый индекс изменяется в некотором диапазоне [a, b]. В языке C#, как и во

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

Массивы в языке C# являются настоящими динамическими массивами. Что такое

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

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

только динамически в процессе выполнения программы, когда становятся известными

значения соответствующих переменных.

В C# имеется три основных типа массивов: одномерные, многомерные и ступенчатые

(jagged) :

Одномерные массивы

Одномерный массив – это список связанных переменных. Для объявления одномерного

массива используется следующая форма записи:тип[] имя массива = new тип[ размер] ;

…int[] k; //k - массивk=new int [3]; //Определяем массив из 3-х целыхk[0]=-5; k[1]=4; k[2]=55; //Задаем элементы массива//Выводим третий элемент массиваConsole.WriteLine(k[2].ToString());…

Смысл приведенного фрагмента ясен из комментариев. Обратите внимание на некоторые

особенности. Во-первых, массив определяется именно как

69

…int[] k;…

а не как один из следующих вариантов:

…int k[]; //Неверно!int k[3]; //Неверно!int[3] k; //Неверно!…

Во-вторых, так как массив представляет собой ссылочный объект, то для создания массива

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

…k=new int [3];…

Именно в ней мы и определяем размер массива. Хотя, вообще говоря, возможны

конструкции вида:

…int[] k = new int [3];…

Элементы массива можно задавать сразу при объявлении. Вот пример:

…int[] k = {-5, 4, 55};…

Разумеется, приведенные конструкции применимы не только к типу int и не только к

массиву размера 3.

В C# нумерация элементов массива идет от нуля до N – 1, где N – размер массива.

Таким образом, в нашем примере начальный элемент массива – это k [0], а последний –

k [2]. Элемента k [3], разумеется, нет. Также необходимо отметить, что доступ к элементам

производится с помощью оператора [ ]:

…int element = k[0];…

70

Теперь переходим к многомерным массивам.

• Хотелось бы отметить, что разделение массивов на одномерные и многомерные

носит исторический характер. Никакой принципиальной разницы между ними

нет. Одномерные массивы – это частный случай многомерных. Можно говорить

и по-другому: многомерные массивы являются естественным обобщением

одномерных. Одномерные массивы позволяют задавать такие математические

структуры как векторы, двумерные – матрицы, трехмерные – кубы данных,

массивы большей размерности – многомерные кубы данных.

Многомерные массивы

Многомерные массивы языка C# являются весьма мощной, надежной, понятной и

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

только профессионалам, но и новичкам, программирующим на C#. Многомерным

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

доступ к отдельному элементу осуществляется посредством двух или более индексов.

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

массивов идентифицируются набором индексов – "координат" в многомерном

пространстве. Каждое измерение имеет свою размерность, не зависящую от других. При

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

Простейший многомерный массив – двумерный. Посмотрим, как он задается:

…int[,] k = new int [2,3];…

Обратите внимание, что пара квадратных скобок только одна. Естественно, что в нашем

примере у массива 6 (=2*3) элементов (k [0,0] – первый, k [1,2] – последний).

Вот пример трехмерного массива:

…int[,,] k = new int [10,10,10];…

А вот так можно сразу инициализировать многомерные массивы:

…int[,] k = {{2,-2},{3,-22},{0,4}};…

Приведенные выше примеры многомерных массивов называются прямоугольными.

Если их представить в виде таблицы (в двумерном случае), то массив будет представлять

71

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

оператора [ ], в котором индексы также указываются через запятую:

…int element = k[0, 1]; // В случае двумерного массива…int element = k[0, 1, 1]; // В случае трехмерного массива…

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

каждый из которых может принимать значения от нуля до N – 1, где N – размер

соответствующего измерения массива.

Рваные массивы

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

называемые ступенчатые (jagged) массивы. Их еще называют рваные массивы. У такого

массива строки могут иметь различную длину. Это, по сути, массивы массивов. Эти

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

произвольное число потомков.

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

Fathers, представляющие отцов, могут задаваться одномерным массивом, так что Fathers[i]

– это i-й отец. Вершины второго уровня представляются массивом массивов – Children,

так что Children[i] – это массив детей i-го отца, а Children[i][j] – это j-й ребенок i-го отца.

Для представления внуков понадобится третий уровень, так что GrandChildren [i][j][k]

будет представлять к-го внука j-го ребенка i-го отца.

Рваные массивы объявляются с помощью наборов квадратных скобок, обозначающих

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

следующий формат записи:

тип[][] имя = new тип[размер][];

Здесь элемент размер означает количество строк в массиве.

72

Приведем пример:…//Объявляем 2-мерный ступенчатый массивint[][] k = new int [2][];//Объявляем 0-й элемент нашего ступенчатого массива//Это опять массив и в нем 3 элементаk[0]= new int[3];//Объявляем 1-й элемент нашего ступенчатого массива//Это опять массив и в нем 4 элементаk[1]= new int[4];k[1][3]=22; //записываем 22 в последний элемент массива…

Обратите внимание, что у ступенчатых массивов мы задаем несколько пар квадратных

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

элементами массива – записываем, читаем и так далее. Самая важная и интересная

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

выше примере в первой "строке" массива k три целых числа, а во второй – четыре.

Посмотрим следующий фрагмент, который при объявлении массива jagged выделяет

память для его первой размерности, а память для его второй размерности выделяется

«вручную»: …int[][]jagged = new int[3][]; jagged[0]= new int[4];jagged[1]= new int[3];jagged[2]= new int[5];… После выполнения этого фрагмента кода массив jagged выглядит следующим образом:

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

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

число 10 элементу массива jagged с координатами 2 и 1, используется следующая

инструкция:

73

…jagged [2][1]= 10;

74

10. Классы В этой главе вы познакомитесь с классом. С# является языком объектно-

ориентированного программирования, поэтому классы играют в нем основополагающую

роль. Это фундамент, на котором построен язык С#. Внутри класса определяются данные

и код действия, выполняемых над этими данными. Этот код сосредоточен в методах.

Получив представление о классах, объектах и методах, вы сможете писать более сложные

программы и лучше понимать ключевые элементы С#, описанные ниже. И еще. Не надо

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

У класса две различные роли: модуля и типа данных. Класс – это модуль,

архитектурная единица построения программной системы. Модульность построения –

основное свойство программных систем. В ООП (объектно-ориентированное

программирование) программная система, строящаяся по модульному принципу, состоит

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

содержательную единицу – его размер и содержание определяется архитектурными

соображениями, а не семантическими. Ничто не мешает построить монолитную систему,

состоящую из одного модуля – она может решать ту же задачу, что и система, состоящая

из многих модулей.

Вторая роль класса не менее важна. Класс – это тип данных, задающий реализацию

некоторой абстракции данных, характерной для задачи, в интересах которой создается

программная система. С этих позиций классы – не просто кирпичики, из которых

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

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

каждый кирпич выполняет определенную функцию: один следит за температурой, другой

– за составом воздуха в доме. ОО-программная система напоминает дом будущего.

Определяя класс, вы определяете данные, которые он содержит, и код,

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

включать только код или только данные, большинство реальных классов содержат и то, и

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

методах.

Класс создается с помощью ключевого слова class. Объявления классов используются

для задания новых ссылочных типов. Язык C# не поддерживает множественного

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

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

методы, свойства, индексаторы, события, операторы, конструкторы, деструкторы и

75

вложенные описания типов. Каждый член класса может иметь спецификатор (описатель)

доступа.

Рассмотрим таблицу:

Описатель Назначениеpublic Члены доступны из всего кодаprotected Члены доступны только из наследуемых классовinternal Члены доступны только из данного классаprotected internal Члены доступны только из наследуемых классов данного классаprivate Члены доступны только из данного класса

Члены класса могут быть закрытыми в рамках класса или более доступными.

Спецификатор доступа определяет, какой именно разрешен тип доступа. Спецификатор

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

(private). Члены с закрытым доступом могут использоваться только другими членами

своего класса.

Несмотря на отсутствие специального синтаксического правила определения класса

(его качественного и количественного состава), класс должен определять только одну

логическую сущность. Например, класс, в котором хранятся имена лиц и их телефонные

номера, не должен также содержать информацию о среднем количестве осадков и прочую

не связанную с конкретными лицами информацию. Другими словами, правильно

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

в один класс логически несвязанные данные, вы рискуете деструктурировать свой код.

Представьте себе, что у вас есть некоторый объект, который характеризуется рядом

свойств. Например, работник фирмы. У него есть такие свойства, как фамилия, возраст,

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

независимых переменных (строкового типа для фамилии, целого типа для возраста и

стажа), а одной переменной типа Worker, внутри которой и содержаться переменные для

фамилии, возраста и стажа. Это здесь самое важное – что в переменной типа Worker

содержаться другие переменные. Конечно, типа Worker среди встроенных типов данных

нет, но мы можем ввести его. Еще одна важная вещь про классы – это то, что в классах

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

работы с этими переменными. Скажем, в нашем примере с классом Worker логично ввести

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

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

не может быть отрицательным или большим 150. Наша функция и будет проверять

правильность введенного пользователем возраста.

76

Давайте рассмотрим первый пример класса. Необходимо чтобы программа вывела на

экран "Иванов, 34".

Для этого, прежде всего, создадим новое приложение для C# и введем следующий текст:using System;

namespace test{ //Начало класса class Worker{ public int age=0; public string name; } //Конец класса

class Test{ static void Main(string[] args){ Worker wrk1 = new Worker(); wrk1.age=34; wrk1.name="Иванов"; Console.WriteLine(wrk1.name+", "+wrk1.age); } }}

Запустите программу. Она, как и следовало ожидать, выведет на экран "Иванов, 34".

Давайте кратко обсудим наш код. Во-первых, в строчках

…class Worker{ public int age=0; public string name; }…

мы определили наш класс Worker. Внутри этого класса существует две переменные –

целая age для возраста и name строкового типа для имени. Обратите внимание, что мы

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

…public int age=0;…

Начальное значение задавать вовсе не обязательно – это видно по переменной name.

Перед переменными мы пишем ключевое слово public. Это означает, что эта переменная

(или функция) будет видна вне класса. Если перед переменной не писать никакого

77

модификатора доступа, или написать private, то пременая не будет видна снаружи класса и

ее смогут использовать только фунции этого же класса (то есть она

будет для "внутреннего использования").

Далее в строчке

…Worker wrk1 = new Worker();…

мы заводим экземпляр класса в куче (heap) и возвращаем на него ссылку. После

выполнения этой инструкции wrk1 станет экземпляром класса Worker, то есть обретет

«физическую» реальность. При каждом создании экземпляра класса создается объект,

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

этим классом. Для доступа к переменным используется оператор «точка» (.). Этот

оператор связывает имя объекта с именем его члена. В строчках

…wrk1.age=34;wrk1.name="Иванов";Console.WriteLine(wrk1.name+", "+wrk1.age);…

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

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

«точка», а его член – справа.

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

виды членов класса.

Конструкторы классов

Для начала кратко обсудим, что такое конструктор вообще. Конструктор – это

функция (метод) класса. Раз эта функция, то описываем мы ее почти точно так же, как и

любую другую функцию класса – пишем параметры в круглых скобках и так далее. Когда

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

несколько конструкторов – но при этом они должны различаться или типом параметров,

или их количеством. Таким образом, конструктор инициализирует объект при его

создании. Он имеет то же имя, что и сам класс, а синтаксически подобен методу (метод

посмотрим далее).

78

Этот пример будет основан на предыдущем. Посмотрите программу, описанную в

предыдущем пункте. Давайте добавим в наш класс Worker конструктор:

… class Worker { public int age=3; public string name; //Конструктор 1 public Worker(int age, string name) { this.age=age; this.name=name; } }…

Обратите внимание на ряд особенностей конструктора. Во-первых, конструктор

называется как класс. Раз наш класс называется Worker, значит и конструктор должен

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

возвращает никакого значения (даже типа void)

Что делает наш конструктор? Он записывает передаваемые в него параметры во

внутренние переменные класса. Обратите внимание, что называются они одинаково – age

и age, name и name. Компилятор сначала ищет локальную переменную с таким именем, и,

если не находит, то переменную класса. Поэтому age (и name) – это передаваемый в

конструктор параметр. Если же нам надо сослаться на переменную класса (при

существавании переменной с таким же именем, как и передаваемый в функцию параметр),

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

нашего класса.

Таким образом, в строчках, мы передаем параметры конструктора в переменные класса:…this.age=age;this.name=name;…Теперь изменим тестовый класс test следующим образом:… static void Main(string[] args) { //Вызываем конструктор Worker wrk1 = new Worker(40, "Вася"); Console.WriteLine(wrk1.name+", "+wrk1.age); }…

79

Поля

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

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

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

создается новый объект класса (в динамической памяти или в стеке), то этот объект

представляет собой набор полей класса. Два объекта одного класса имеют один и тот же

набор полей, но разнятся значениями, хранимыми в этих полях. Все объекты класса

Person могут иметь поле, характеризующее рост персоны, но один объект может быть

высокого роста, другой – низкого, а третий – среднего роста.

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

public, private, protected, internal.using System;

Приведем наглядный пример:

public class MyClass{ // Указывается что это поле доступно из любого класса, даже из другой сборки // Также можно указать protected - поле будет доступно только из классов-наследников // и private - доступно только из текущего класса. public int a;

// Присваиваем начальное значение в конструкторе public MyClass(){ a = 3; }}

public class Application{ public static void Main(){ MyClass myClass = new MyClass(); // В консоли выводится значение a = 3 Console.WriteLine("a = {0}", myClass.a);

myClass.a += 5;

// В консоли выводится значение a = 8 Console.WriteLine("a = {0}", myClass.a); } }

80

Результат работы программы ниже.

Методы

Методы представляют собой процедуры (подпрограммы), которые манипулируют

данными, определенными в классе, и во многих случаях обеспечивают доступ к этим

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

его методов. Методы класса синтаксически являются обычными процедурами и

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

Два объекта одного класса имеют один и тот же набор методов. Возможные модификаторы

– public, static, protected, abstract и еще virtual, override, new и extern.

static – то же самое, что и у полей. Указывает, что метод принадлежит классу, а не

конкретному экземпляру, работать такой класс может только со статическими членами.

virtual – указывает, что метод может быть переопределен (override) в потомках.

Для перегрузки методов в потомках используются модификаторы new и override. При

использовании модификатора new, метод потомка вызывается лишь в значениях класса

потомка, а при использовании override – в любом случае – метод предка замещается.

Модификатор override может быть использован только для виртуальных методов.

Любой метод содержит одну или несколько инструкций. В хорошей C# – программе

один метод выполняет только одну задачу. Каждый метод имеет имя, и именно это имя

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

параметрилизуют его действия.

Формат списка параметров такой:

модификатор параметра тип параметра имя параметра

Единственной необычной частью является модификатор параметра. Существуют

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

out – указывает, что значение параметра не передается в метод, а возвращается из

него. Реально это означает, что можно передавать только переменную, она может

быть не инициализирована и ее значение может быть изменено в методе.

81

ref – указывает, что параметр передается по ссылке. То есть, если в теле метода

будет изменено его значение, изменится и значение передаваемой переменной. С

модификатором ref передаваться могут только переменные.

Возвращение из метода

В общем случае существует два варианта для возвращения из метода. Первый связан с

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

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

инструкции return: одна предназначена для void - методов (которые не возвращают

значений), а другая – для возврата значений. Мы рассмотрим первую форму.

Немедленное завершение void - метода можно организовать с помощью следующей

формы инструкции return:return;При выполнении этой инструкции управление программой передается автору вызова

метода, а оставшийся код опускается. Рассмотрим, например следующий метод:public void myMeth(){ int i; for(i=0; i<10; i++){ if(i == 5)return; //Прекращается выполнения метода при i=5. Console.WriteLine(); } }

Здесь цикл for будет работать при значениях i в диапазоне только от 0 до 5, поскольку, как

только значение i станет равным 5, будет выполнен возврат из метода myMeth().

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

произойдет либо в случае его корректного завершения, либо при возникновении ошибки.

public void myMeth(){//…if (done)return;//…if(error) return;}

Свойства

Рассматривая классы языка C#, просто нельзя обойти такое «новшество», как свойства

(properties). Свойства расширяют возможности полей. Они представляют специальную

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

свойствами. При работе со свойствами объекта (полями) часто нужно решить, какой

82

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

класса. Перечислим пять наиболее употребительных стратегий:

чтение, запись (Read, Write);

чтение, запись при первом обращении (Read, Write-once);

только чтение (Read-only);

только запись (Write-only);

ни чтения, ни записи (Not Read, Not Write).

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

значение и (опционально) записать в них новое значение. При выполнении этих действий

выполняется определяемый программистом код.

• Использование пробелов и круглых скобок

Любое выражение в C# для повышения читабельности может включать пробелы (или

символы табуляции). Например, следующие два выражения совершенно одинаковы, но

второе прочитать гораздо легче:

x=10/y*(127/x); x = 10 / y * (127 / x);

Круглые скобки (так же, как в алгебре) повышают приоритет операций, содержащихся

внутри них. Использование избыточных или дополнительных круглых скобок не приведут

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

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

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

x = y/3-34*temp+127; x =(y/3)-(34*temp) + 127;

83

11. Вспомогательный материал

Работа с консолью Для плодотворной работы с нашим учебником надо иметь возможность компилировать

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

исполнения – исполняющая среда .NET (или CLR), которая представляет собой набор

динамически подключаемых библиотек.

Все это есть в Microsoft Visual C#, современной интегрированной среде разработки.

Вместо Visual C# можно приобрести более мощную (и, естественно, более дорогую) среду

Microsoft Visual Studio .NET, которая в дополнение к C# позволяет программировать на

C++ и Visual Basic. Если вы сторонник варианта «дешево и сердито», можно скачать

бесплатный пакет для разработки программ .NET (.NET Framework SDK). В него входят

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

http://msdn.microsoft.com/downloads, выберите слева ссылку Software Development Kits и

найдите в списке .NET Framework (помните, что в любой момент содержимое и адрес

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

могут вовсе исчезнуть).

Как сказано в предыдущем разделе, для эффективной работы с учебником читатель

должен иметь возможность компилировать и исполнять программы на C#. К системе же

предъявляются такие требования:

• Microsoft .NET Framework SDK (минимум), Microsoft Visual C# или Microsoft Visual

Studio .NET (рекомендуется);

• Microsoft Windows NT 4.0, Windows 2000 или Windows XP.

Чтобы программы, написанные на C#, можно было исполнять на других компьютерах,

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

распространяемым пакетом .NET Framework). Этот пакет поставляется вместе с

.NET Framework SDK, Visual C# и Visual Studio .NET и может быть установлен в

вышеупомянутые версии ОС Windows, а также в Windows 98 и Windows Millennium

Edition (ME).

Теперь попробуем кратко описать основные приемы работы с консолью. Это не

относится непосредственно к C#, но поможет читать приведенный в учебнике код и

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

Для работы с консолью в .NET используется класс Console. Удобство использование

этого класса кроется в двух аспектах: все его методы являются статическими, так что не

84

http://msdn.microsoft.com/downloads

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

вывод и вывод ошибок. По умолчанию ввод/вывод производится на стандартную консоль

(если ее нет, например, в оконных приложениях, вывод просто не производится), но

устройства ввода и вывода можно изменить.

Для работы с консолью обычно используется 4 метода:

o Read

o ReadLine

o Write

o WriteLine

Методы Read и ReadLine используются для ввода, а методы Write и WriteLine

используются для вывода. Теперь рассмотрим эти методы более конкретно опираясь на

примеры.

o Метод Read

Метод Read читает символ из потока ввода. Он возвращает значение типа int, равное коду

прочитанного символа, либо – 1, если ничего прочитано не было. Приведем пример

программы, в которой на экран выводятся введенные символы и их коды.:do{ int i = Console.Read();

if (i != -1) Console.WriteLine("{0} ({1})", (char)i, i); else break;} while (true);

o Метод ReadLine

Метод ReadLine читает из потока ввода строку текста (она завершается символом

перевода строки или возврата каретки). Метод возвращает объект типа string или null, если

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

do{ string s = Console.ReadLine();

if (s != null) Console.WriteLine("Введенная строка: " + s); else break;} while (true);

85

o Методы Write и WriteLine

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

в том, что метод WriteLine выводит символ перевода строки в конце.

Итак, метод Write выводит на экран значение переданной ему переменной. Он определен

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

либо вызвать Write с указанным значением в качестве параметра:

Console.Write(1);Console.Write(0.754);Console.Write("Hello!");

Либо передать строку форматирования и список значений. В строке форматирования

применяется множество модификаторов, здесь мы отметим лишь, что вместо "{n}"

подставляется n-й входной параметр (нумерация начинается с 0):

Console.Write("Привет, {0}", Name);

86

Documents

Programmeerimiskeele C# õppematerjal › osakond › opilaste_tood › seminari_ja... · В c# предусмотрен богатый набор встроенных типов