Основы C#. Примеры лабораторных работ: Лабораторный практикум/ О.П. Якимова; Яросл. гос. ун-т им. П.Г. Демидова. Ярославль, 2010. с.

Лабораторный практикум предназначен для студентов специальности «компьютерная безопасность» и «прикладная математика и информатика» математического факультета ЯрГУ, изучающих программирование на языке C#.

Печатается по решению научно-методического совета Ярославского государственного университета им. П.Г. Демидова

Рецензент – кафедра компьютерной безопасности и математических методов обработки информации Ярославского государственного университета им. П.Г. Демидова

©  Ярославский государственный университет им. П.Г. Демидова, 2010 ©  О.П. Якимова, 2010

Содержание

Введение...............................................................................................4

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

Предварительные замечания ............................................................ 6 Создание первой программы .............................................................6

Лабораторная работа № 1: Простейшие конструкции языка....... 11

Лабораторная работа № 2: Табулирование функции, заданной бесконечным рядом .........................................................22

Лабораторная работа № 3: Вычисления с хранением последовательностей значений ....................................................... 24

Лабораторная работа № 4: Обработка последовательностей символов............................................................................................. 33

Лабораторная работа № 5: Графические построения

при решении геометрических задач................................................. 45

Лабораторная работа № 6: Матричные задачи.............................. 59

Список литературы ........................................................................... 66

Введение

Microsoft .NET Framework – это программная технология, основной задачей которой является предоставление разработчику набора очень удобных средств для разработки как простых программ, так и web приложений. Платформа .Net вобрала в себя все самое лучшее, что когда-либо создавали Microsoft и ее конкуренты. Ее преимущества:

• полная сквозная интеграция языков ( говоря проще, разные части проекта могут быть написаны на разных .Net совместимых языках программирования – и все будет работать!);

• обширная библиотека базовых классов;

• упрощенная модель развертывания программного продукта( в .Net не надо регистрировать двоичные компоненты в системном реестре, установка приложения осуществляется простым копированием);

• безопасный код.

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

Специально для этой платформы Microsoft разработала новый язык программирования C#. Синтаксис C# очень похож на Java, многие конструкции аналогичны C++, но все-таки это новый язык. Строгий, гибкий и многофункциональный. Хотя скорость работы идентично реализованных алгоритмов на языках C# и С++ различаются примерно в 2 раза (в пользу С++), при использовании unsafe (небезопасного) кода, C# практически догоняет по скорости выполнения С++. Если учесть то, насколько сильно распространена операционная система Windows, а так же насколько удачным получился продукт, то справедливо предположить, что специалисты в данной области будут очень востребованы в ближайшем будущем.

Подобно технологии Java, среда разработки .NET из исходного кода программы создаёт байт-код, предназначенный для исполнения виртуальной машиной. Входной язык этой машины в .NET называется MSIL (Microsoft Intermediate Language), или CIL (Common Intermediate Language) или просто IL. Применение байт-кода предназначено для получения кроссплатформенности на уровне скомпилированного, а не только на уровне исходного текста программы, как, например, в языке С. С помощью JIT-компилятора (just in time, компиляция на лету), непосредственно перед запуском сборки, в среде исполнения CLR происходит преобразование байт-кода в машинные коды целевого процессора.

Часто разработчикам приходится писать программы на разных языках программирования. Библиотека классов .Net Framework позволяет разработчикам использовать один программный интерфейс для всех функциональных средств CLR. Универсальность библиотеки классов .net является одной из ее сильнейших сторон.

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

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

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

1) 32-разрядная операционная система Microsoft Windows 98, ME, 2000, XP, Vista, 7.

2) Интегрированная среда разработки Microsoft Visual Studio .NET 2008, 2010, Express Edition 2008, 2010. Среду разработки можно бесплатно скачать с сайта www.microsoft.com/express/downloads/.

Предварительные замечания

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

Как результат, разработка программ в среде MS Visual Studio .NET будет показываться на примере конкретных практических действий. Опыт разработки алгоритмов для решения учебных задач даст реальную основу для перехода к успешному освоению ООП. Задачи, которые приводятся в данном пособии взяты из [1, 2, 3, 5].

Создание первой программы

Традиционно, первой программой в большинстве учебников по программированию является программа, которая выводит на печать строку: «Hello, world!». Не будем отказываться от традиций и создадим наше первое приложение – HelloWorld.

Для этого запустите MS Visual Studio, после чего создайте новый проект, используя пункты меню File – New – Project, как показано на рисунке 1.

Рисунок 1. Создание нового проекта.

Выберите проекты Visual C#, в шаблонах отметьте Console Application (консольное приложение) и введите имя для нашего проекта : HelloWorld. По умолчанию все проекты сохраняются в папке «Мои документы\Visual Studio 2008\Projects», но Вы можете указать свой каталог.

Рисунок 2. Выбор типа проекта.

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

Рисунок 3. Шаблон консольного приложения

В него нам необходимо добавить 2 строки кода: первая будет выводить на экран сообщение “Hello World”, вторая будет ожидать символ, введенный пользователем, только после этого программа завершится. Ожидание ввода нам необходимо, чтобы прочитать вывод строки программой, иначе мы просто не успеем его увидеть – программа выполнит код и завершится.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace HelloWorld

{

class Program

{

static void Main(string[] args)

{

// выводим текст в консоль Console.WriteLine("Hello world!!!");

// ждем нажатия клавиши пользователем...

Console.ReadKey();

}

}

}

После того как вы набрали данный код, достаточно нажать F5 и программа будет запущена, после чего вы сможете увидеть результат ее работы. Запуск программы можно произвести и через пункты меню Debug – Start Debugging.

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

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

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

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

Рассмотрим остальные строки кода. Понятно, что Console.WriteLine –это метод вывода на печать, Console.ReadKey - метод, ждущий нажатия на любую клавишу, а комментарии в C# начинаются с //.

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

Лабораторная работа №1: Простейшие конструкции языка

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

Разберем несколько примеров.

Пример 1.1. Даны две целые переменные a, b. Составить программу, после исполнения которой значения переменных поменялись бы местами( новое значение a равно старому значению b и наоборот).

Опишем две целочисленные переменные, чьи значения нам даны и дополнительную переменную d:

int a, b, d;

Теперь введем значения a и b с клавиатуры. Стандартный метод ввода с консоли возвращает строку. Поэтому при вводе необходимо произвести преобразование из строки в число.

Console.Write(“ Введите значение а ”);

// чтение строки и преобразование ее в целое число

a = int.Parse(Console.ReadLine());

Далее собственно обмен значений.

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

a = b; // помещаем в а значение b

b = d; // помещаем в b значение из d

Распространенная ошибка:

a=b;

b=a;

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

static void Main()

{

int a, b, d; // описание целочисленных переменных

// ввод данных

Console.Write(" Введите значение а ");

// чтение строки и преобразование ее в целое число

a = int.Parse(Console.ReadLine());

Console.Write(" Введите значение b ");

b = int.Parse(Console.ReadLine());

// обмен значений

d = a; //сохраняем значение а в d

a = b; // помещаем в а значение b

b = d; // помещаем в b значение из d

// вывод значений a и b

Console.WriteLine(" a = { 0}, b = {1} ", a ,b);

Console.ReadKey();

}

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

if ( a > b)

{ // выполняется, если условие истинно

Console.WriteLine(“ Число a = {0} больше”, a);

}

else // выполняется, если условие ложно

Console.WriteLine(“ Число b = {0} больше ”, b);

Пример 1.2. Даны целые числа a, b, c. Найти минимальное из этих трех чисел.

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

int a, b, с; // описание целочисленных переменных

// ввод данных

Console.Write(" Введите значение а ");

// чтение строки и преобразование ее в целое число

a = int.Parse(Console.ReadLine());

Ввод значений b и c аналогичен. Теперь основная логика.

if (a >= b)

{

if (b >= c)

Console.WriteLine(" Максимальное значение = {0}", a);

else // здесь a>b, b<c

{ if (a >= c)

Console.WriteLine(" Максимальное значение = {0}", a);

else Console.WriteLine(" Максимальное значение = {0}", c);

}

}

else // a < b

{

if ( b >= c)

Console.WriteLine(" Максимальное значение = {0}", b);

else // здесь b < c

Console.WriteLine(" Максимальное значение = {0}", c);

}

Каскад условий, вложенных друг в друга, можно упростить, если использовать логические операции. Логическое «И» в C# обозначается как &&, логическое «ИЛИ» - как ||, логическое отрицание - как !. Приведем полный код решения этой задачи с использованием логических операций.

static void Main(string[] args)

{

int a, b, c; // целочисленные переменные

// ввод данных

Console.Write(" Введите значение а ");

// чтение строки и преобразование ее в целое число

a = int.Parse(Console.ReadLine());

Console.Write(" Введите значение b ");

b = int.Parse(Console.ReadLine());

Console.Write(" Введите значение с ");

c = int.Parse(Console.ReadLine());

// поиск максимального из трех чисел

if ((a >= b) && (a >= c))

Console.WriteLine(" Максимальное значение = {0}", a);

else

{ if ((b >= a) && ( b >c))

Console.WriteLine(" Максимальное значение = {0}", b);

if ((c >= a) && (c >=b))

Console.WriteLine(" Максимальное значение = {0}", c);

}

Console.ReadKey();

}

Для решения следующего примера познакомимся с синтаксисом оператора цикла. В C# существуют четыре вида операторов цикла. Циклы реализуются с помощью следующих зарезервированных слов: while , do while , for, foreach .

Рассмотрим каждый на примере. Заметим, что переменные, объявленные в цикле (в том числе в заголовке цикла for и foreach) не видны снаружи цикла.

Оператор цикла while. Пока истинно управляющее  условие,  выполняется оператор (или  тело цикла ). Пример: вычислим значение aⁿ, если дано целое a и натуральное n. Для простоты будем значения a и n задавать прямо в программе. int a = 17;

byte n = 6,

k=1;

int rez = 17;

while ( k < n)

{

rez = rez * a;

k++; // увеличение k на единицу. Эквивалентно k=k+1

}

Console.WriteLine(“ {0} в степени {1} равно {2} ”, a, n, rez);

Оператор цикла do-while. В данном случае, тело цикла выполняется до проверки условия.

int a = 17;

byte n = 6,

k = 1;

int rez = 17;

do {

rez = rez * a;

k++; // увеличение k на единицу

} while ( k < n);

Console.WriteLine(“ {0} в степени {1} равно {2} ”, a, n, rez);

Оператор цикла for. Цикл for  используют, как правило,  когда число повторений известно заранее, т.е. в задачах связанных с перебором. Мы устанавливаем начало отсчета, условие остановки, и тип изменения параметра. Рассмотрим тот же пример с возведением числа a в степень n.

int a = 17;

byte k, n = 6;

int rez = 17;

for( k=1; k< n; k++)

rez = rez * a;

Console.WriteLine(“ {0} в степени {1} равно {2} ”, a, n, rez);

В C# существует еще один оператор цикла - foreach. Этот цикл полезен, когда необходимо перебрать все элементы массива или иной коллекции. Подробно мы рассмотрим его позже.

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

Пример 1.3. Дано натуральное n и действительные числа a₁, …, a_n. Все члены этой последовательности, начиная с первого положительного, уменьшить на 0,5.

Прежде всего опишем необходимые для работы переменные.

byte n; // натуральное n – число членов последовательности

double a; // действительная переменная

int count; // вспомогательная переменная - счетчик

Далее стандартным способом получим значение n:

Console.Write(" Введите значение n ");

// чтение строки и преобразование ее в целое число

n = byte.Parse(Console.ReadLine());

Пользователь нашей программы может совершить ошибку и ввести нулевое значение n (если он введет отрицательное значение, то программа завершится с ошибкой, так как тип byte допускает числа от 0 до 255). Поэтому нам необходима проверка.

if (n == 0) // проверка на равенство нулю

{

Console.WriteLine(" значение n должно быть >0 ");

return; // завершение работы программы

}

Теперь мы можем поочередно вводить члены последовательности a_i и проверять их на положительность.

Console.Write(" Введите значение a ");

a = double.Parse(Console.ReadLine());

count = 1; // счетчик введенных членов последовательности

while ((count <= n) && (a <= 0))

{

Console.Write(" Введите значение a ");

a = double.Parse(Console.ReadLine());

count++;

}

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

if (a > 0)

{

a=a - 0.5;

Console.WriteLine(" Измененное значение a = {0} ", a);

while (count < n)

{

Console.Write(" Введите значение a ");

a = double.Parse(Console.ReadLine());

count++;

a = a - 0.5;

Console.WriteLine(" Измененное значение a = {0} ", a);

}

}

Как и раньше, приведем полный код решения:

static void Main()

{

byte n; // число членов последовательности

double a; // действительная переменная

int count; // счетчик

Console.Write(" Введите значение n ");

// чтение строки и преобразование ее в целое число

n = byte.Parse(Console.ReadLine());

if (n == 0)

{

Console.WriteLine(" значение n должно быть >0 ");

return;

}

Console.Write(" Введите значение a ");

a = double.Parse(Console.ReadLine());

count = 1;

while ((count < n) && (a <= 0))

{

Console.Write(" Введите значение a ");

a = double.Parse(Console.ReadLine());

count++;

}

if (a > 0)

{

a=a - 0.5;

Console.WriteLine(" Измененное значение a = {0} ", a);

while (count < n)

{

Console.Write(" Введите значение a ");

a = double.Parse(Console.ReadLine());

count++;

a = a - 0.5;

Console.WriteLine(" Измененное значение a = {0} ", a);

}

}

Console.ReadKey();

}

Пример 1.4. Дано натуральное n и целые числа a₁, …, a_n. Найти количество четных членов последовательности.

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

static void Main(string[] args)

{

byte n; // число членов последовательности

int a; // целочисленная переменная

int count, even_n; // счетчики

// ввод n и проверка на допустимость

Console.Write(" Введите значение n ");

n = byte.Parse(Console.ReadLine());

if (n == 0)

{

Console.WriteLine(" значение n должно быть >0 ");

return;

}

//основной цикл. Ввод и проверка на честность

count =0; // инициализация счетчиков

even_n =0;

while (count < n)

{

Console.Write(" Введите значение a ");

a = int.Parse(Console.ReadLine());

if (a % 2 == 0) //если остаток от деления на 2 равен 0,

even_n++; // то увеличиваем счетчик четных чисел

count++;

}

Console.WriteLine(" Количество четных чисел = {0} ", even_n);

Console.ReadKey();

}

Пример 1.5. Даны целые числа a₁,a₂ …. Известно, что a₁>0 и что среди a₂, a₃, … есть хотя бы одно отрицательное число. Пусть a₁, a₂, …, a_n – члены данной последовательности, предшествующие первому отрицательному числу ( n заранее неизвестно). Найти min( a₁+ a₂, a₂+a₃, …, a_n-1 + a_n).

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

static void Main(string[] args)

{

int pred; // предыдущий член последовательности

int a; // текущий член последовательности

int min; // минимум

// ввод первых двух членов последовательности

Console.Write(" Введите значение а ");

pred = int.Parse(Console.ReadLine());

Console.Write(" Введите значение а ");

a = int.Parse(Console.ReadLine());

//если а₂<0, то выход

if (a < 0)

{

Console.WriteLine(" значение минимума ={0} ", pred);

return;

}

min = pred + a; //инициализация минимума

pred = a;

// ввод третьего члена последовательности

Console.Write(" Введите значение а ");

a = int.Parse(Console.ReadLine());

//основной цикл. Пока не встретим отрицательное а

while ( a >= 0)

{

if ((a +pred) < min) //если меньше тек. зн-я минимума,

min = a+pred; // то переприсваиваем

pred = a;

Console.Write(" Введите значение a ");

a = int.Parse(Console.ReadLine());

}

Console.WriteLine(" значение минимума = {0} ", min);

Console.ReadKey();

}

Задания для лабораторной работы № 1

1. Треугольник задан координатами своих вершин. Найти площадь и периметр треугольника.

2. Дано действительное число а. Вычислить f(a), если

f(x) =

3. Даны натуральное число n, действительные числа a₁, …, a_n. Вычислить:

1. a₁- a₂+ a₃- …+(-1)ⁿ⁺¹ a_n;

2. 2(a₁ + .. + a_n)²;

3. sin| a₁+ ..+ a_n|.

4. Даны натуральное число n, целые числа p, q, a₁, …, a_n( p > q ≥0). В последовательности a₁, …, a_n заменить нулями члены, модуль которых при делении на p дает в остатке q.

5. Даны натуральное n, действительные числа a₁, …, a_n. Получить min(a₁³, …, a_n³).

Лабораторная работа 2: Табулирование функции, заданной бесконечным рядом

Цель работы. Написать программу, которая выполняет вычисления с некоторой точностью. Дана функция, заданная бесконечным рядом. С клавиатуры вводятся x и e (е - точность 0.001 - 0.00001), нужно вычислить бесконечную сумму с заданной точностью e. Вычисления прекращаются, когда очередное слагаемое по модулю меньше точности. Требуется вывести на экран таблицу значений i и суммы i слагаемых.

Разберем эту задачу на примере функции:

Нам потребуются следующие переменные:

float x, e; // для хранения входных данных

double slag, sum; // для суммы и очередного слагаемого

int i; // счетчик слагаемых

Представим функцию в виде:

Теперь слагаемое состоит из двух множителей. Заметим, что для первого множителя для перехода от i к i+1 необходимо умножить числитель на –x, а знаменатель на (i+ 1). Это замечание позволит нам отказаться от вложенного цикла для вычисления степени и факториала. Приведем код программы целиком.

static void Main()

{

float x = 1; // аргумент функции

float e; // точность

double slag, sum; // для суммы и очередного слагаемого

int i; // счетчик слагаемых

// ввод исходных данных

Console.WriteLine("x=");

x = float.Parse(Console.ReadLine());

Console.WriteLine("e=");

e = float.Parse(Console.ReadLine());

// вычисление первого слагаемого

i = 1;

slag = 1;

sum = 1 / 3;

// вывод на печать заголовка таблицы

Console.WriteLine(" i slag sum ");

Console.WriteLine(" {0} {1} {2}", i, slag, sum);

// цикл, пока слагаемое по модулю больше точности

while (Math.Abs(slag/(i+2)) > e)

{

i++;

slag = slag* (-1) * x / i; // очередное слагаемое

sum = sum + slag / (i + 2);

Console.WriteLine(" {0} {1} {2}", i, slag, sum);

}

// задержка экрана до нажатия клавиши Enter

Console.ReadLine();

}

Как проверить, правильно ли работает программа? Протестировать ее, то есть задать входные данные и посмотреть соответствуют ли выходные данные вычисленным вручную. Конечно, выполнять на листке бумаги сложные вычисления довольно затруднительно. Выходом из этой ситуации является подбор входных данных. Для разобранной выше задачи значение x= 1 или x = -1 и e = 0,1 позволит легко проверить программу на корректность.

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

Math.Cos( x) – возвращает косинус действительного x;

Math.Sin( x) – возвращает синус действительного x;

Math.Exp( x) – возвращает e^x;

Math.Sqrt( x) – возвращает квадратный корень из x;

Math.Pow( x, y) – возвращает x^y.

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

Задания для лабораторной работы № 2

f(x) = .	6. f(x) = .
2. f(x) = .	7. f(x) = .
3. f(x) = .	8. f(x) = .
4. f(x) = .	9. f(x) = .

5. f(x) = . 10. f(x) = .

Лабораторная работа № 3: Вычисления с хранением последовательностей значений

Цель работы. Решить задачу на обработку одномерного массива. Требуется ввести с клавиатуры размерность массива n, далее в цикле ввести элементы массива. Полученный ответ вывести на экран.

Типичным заданием лабораторной работы № 3 является следующее:

Пример 3.1. Дано натуральное n, целые числа a₁, …, a_n ( все числа попарно различны). Поменять в этой последовательности местами наибольший и наименьший члены.

В отличие от лабораторной работы № 1 введенные числа нам придется где-то хранить, так как при первом просмотре последовательности мы можем найти минимум и максимум, а обмен произвести нельзя, нужен второй просмотр, где и произойдет обмен значений. Для хранения однотипных данных используются массивы.

Массив – это множество однотипных элементов. Доступ к элементу массива осуществляется по индексу. В C# существует три вида массивов: одномерные, многомерные и вложенные массивы. Все их можно использовать в циклах foreach.

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

int[] arr_name;

double[] arr_name2;

Здесь arr_name и arr_name2 - имена массивов. Массив мало объявить, его нужно ещё определить, то есть задать количество элементов. Только тогда соответствующее множество однотипных объектов будет размещено в памяти. Массив можно определить сразу же после описания, а можно в любом другом месте программы, до первого обращения к элементам массива. Например:

arr_name= new int[10]; //определение ранее описанного масива

byte [] m = new byte[20]; //одновременное определение и описание

int n =100;

float [] vect = new float [n]; // n должно быть определено!

Нумерация элементов массивов, так же, как в языке С/C++, начинается с нуля. Поэтому первый элемент доступен через следующее обращение - arr_name[0], последний - arr_name[9].

Теперь рассмотрим, как мы можем заполнить массивы значениями, а именно - два способа заполнения. Первый способ – перебор в цикле всех элементов массива и присвоение им значений( через ввод с клавиатуры или путем вычисления по некоторой формуле):

int n = 10;

int[] arr_name = new int[n];

for (int i = 0; i < n; i++)

{

Console.Write(" arr_name[ {0} ] = ", i);

arr_name[i] = int.Parse(Console.ReadLine());

}

Второй способ – задание элементов массива сразу при описании:

int [] arr_name = new int[] {1, 2, 3, 4, 5}; // или так

int [] arr_name = {1, 2, 3, 4, 5};

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

max = arr_name[0];

k = 1;

while( k < arr_name.Length)

{ if( arr_name[k] > max )

max = arr_name[k];

k++;

}