Язык С#. Основы языка. Лекция #1

1. Язык С#

Основы языка
Лекция #1
1

2. Классы

Classes
2

3. Классы в C#

// Обычно для файлов классов C# используется расширение *.cs
using System;
class HelloClass
{
// Как ни удивительно, функция Main() может быть объявлена как private,
// если, конечно, вам это нужно…
public static int Main (string[] args)
{
Console.WriteLine ("Hello, World");
return 0;
}
}
3

4. Обработка параметров командной строки

using System;
class HelloClass
{
public static int Main (string[] args)
{
// Выводим параметры на консоль!
for(int x=0; x < args.Length; x++)
{
Console.WriteLine("Arg: {0}", args[x]);
}
Console.WriteLine("Hello, World!");
return 0;
}
}
using System;
class HelloClass
{
public static int Main (string[] args)
{
foreach(string s in args)
Console.WriteLine("Arg: {0}", args[x]);
}
}
4

5. Создание объектов: конструкторы

// HelloClass с конструкторами
using System;
class HelloClass
{ // Конструктор по умолчанию присвоит переменным-членам значения по умолчанию
public HelloClass()
{
Console.WriteLine("Default constructor called!");
}
// Наш собственный конструктор присвоит переменным-членам специальные значения
public HelloClass(int x, int y)
{
Console.WriteLine("Custom constructor called!");
intX = x; intY = y;
}
// Объявляем переменные-члены класса
public int intX, intY;
// Точка входа для программы
public static int Main(string[] args)
{ // Применяем конструктор по умолчанию
HelloClass c1 = new HelloClass();
Console.WriteLine("c1.intX = {0}\nc1.intY = {1}\n", c1.intX, c1.intY);
// Применяем конструктор с параметрами
HelloClass c2 = new HelloClass(100, 200);
Console.WriteLine("c2.intX = {0}\nc2.intY = {1}\n", c2.intX, c2.intY);
return 0;
}
}
5

6. Композиция приложения C#

class HelloClass
{
public HelloClass(){ Console.WriteLine("Default ctor called!"); }
public HelloClass (int x, int y)
{
Console.WriteLine ("Custom ctor called!");
intX = x; intY = y;
}
public int intX, intY;
// Новая функция-член
public void SayHi() {Console.WriteLine("Hi there!");}
}
class HelloApp
{
public static int Main(string[] args)
{
// Создаем объекты HelloClass и выводим приветствие
HelloClass c1 = new HelloClass();
c1.SayHi();
...
}
}
6

7. Инициализация членов класса

class Text
{
private int MyInt = 90;
private string MyStr = 90;
private Person stud1 = new Person(”Маша”, 19, 3216565);
. . .
}
7

8. Ввод/вывод с использованием класса Console

// Применяем класс Console для ввода и вывода данных
using System;
class BasicIO
{
public static void Main(string[] args)
{
// Выводим приглашение ввести имя
Console.Write("Enter your name: ");
string s;
s = Console.ReadLine();
Console.WriteLine("Hello, {0}", s);
Console.Write("Enter your age: ");
s = Console.ReadLine();
Console.WriteLine("You are {0} years old\n", s);
}
}
8

9. Средства форматирования строк

using System;
class BasicIO
{
public static void Main(string[] args)
{
...
int theInt = 90;
float theFloat = 9.99;
BasicIO myIO = new BasicIO();
// Комбинируем символьную строку:
Console.WriteLine("Int is: {0}\nFloat is: {1}\nYou are: {2}",
theInt,
theFloat, myIO.ToString());
}
}
// Применяем параметры форматирования
public static void Main(string[] args)
{
...
Console.WriteLine("C format: {0:C}", 99989,987);
Console.WriteLine("D9 format: {0:D9}", 99999);
Console.WriteLine("E format: {0:E}", 99999,76543);
Console.WriteLine("F format: {0:F3}", 99999,9999);
Console.WriteLine("N format: {0:N}", 99999);
Console.WriteLine("X format: {0:X}", 99999);
Console.WriteLine("x format: {0:x}", 99999);
}
9

10. Структурные и ссылочные типы

class ValRefClass
{
// Экспериментируем со структурными типами
public static int Main(string[ ] args)
{
// При создании структуры с применением конструктора по умолчанию
// использование ключевого слова "new" является необязательным
FOO f1 = new FOO();
f1.x = 100;
f1.y = 100;
// Присваиваем новому типу FOO (f2) существующий тип FOO (f1)
FOO f2 = f1;
// Выводим содержимое f1
Console.WriteLine("F1.x = {0}", f1.x);
Console.WriteLine("F1.y = {0}", f1.y);
// Выводим содержимое f2
Console.WriteLine("F2.x = {0}", f2.x);
Console.WriteLine("F2.y = {0}", f2.y);
// А теперь вносим изменения в f2.x. Они не отразятся на f1.x
Console.WriteLine ("Changing f2.x");
f2.x = 900;
// Снова выводим содержимое
Console.WriteLine("F2.x = {0}", f2.x);
Console.WriteLine("F1.x = {0}", f1.x);
return 0;
}
}
10

11. Структурные и ссылочные типы

struct FOO
{
public int x,y;
}
class FOO
{
public int x,y;
}
11

12. Класс System.Object

12

13. Объект System.Object

// Самый верхний класс в иерархии классов .NET:
// System.Object
namespace System
{
public class Object
{
public Object();
public virtual Boolean Equals (Object obj);
public virtual Int32 GetHashCode();
public Type GetType();
public virtual String ToString();
protected virtual void Finalize();
protected Object MemberwiseClone();
}
}
13

14. Объект System.Object

// Создаем объекты и знакомимся с методами, унаследованными от System.Object
using System;
class ObjTest
{
public static int Main(string[] args)
{
// Создаем экземпляр ObjTest
ObjTest c1 = new ObjTest();
// Выводим информацию на консоль
Console.WriteLine("ToString: {0}", c1.ToString());
Console.WriteLine("Hash Code: {0}", c1.GetHashCode());
Console.WriteLine("Type: {0}", c1.GetType().ToString());
// Создаем еще одну ссылку на c1
ObjTest c2 = c1;
object o = c2;
// Действительно ли все три экземпляра указывают на одну
// и ту же область в оперативной памяти?
if(o.Equals(c1) && c2.Equals(o))
Console.WriteLine("Same instance!");
return 0;
}
}
14

15. Замещение методов System.Object

// Помните! Все классы в конечном итоге производятся от класса
// System.Object
class Person
{
public Person(string fname, string lname, string inn, byte a)
{
firstName = fname;
lastname = lname;
INN = inn;
age = a;
}
public Person(){} // Всем переменным-членам будут присвоены
// значения по умолчанию
// Данные о человеке
public string firstName;
public string lastName;
public string INN;
public byte age;
}
15

16. Замещение методов System.Object

// Ссылка на это пространство имен необходима для получения
// доступа к типу StringBuilder
using System.Text;
// В нашем классе Person метод ToString будет реализован
// следующим образом:
class Person
{
...
// Замещаем метод, унаследованный от System.Object:
public override srting ToString()
{
StringBuilder sb = new StringBuilder()
sb.Append("[FirstName= " + this.firstName);
sb.Append(" LastName= " + this.lastName);
sb.Append(" INN= " + this.INN);
sb.Append(" Age= " + this.age + "]");
return sb.ToString();
}
...
}
16

17. Замещение методов System.Object

// Наш класс Person реализует метод Equals() таким образом:
class Person
{
...
public override bool Equals (object o)
{// Совпадают ли у объекта, принимаемого в качестве
// параметра, значения переменных с моими?
Person temp = (Person)o;
if (temp.firstName = = this.firstName &&
temp.lastName = = this.lastName &&
temp.INN = = this.INN &&
temp.age = = this.age)
return true;
else
return false;
}
public override int GetHashCode() { return INN.GetHashCode(); }
...
}
17

18.

// Создаем несколько объектов Person и экспериментируем с замещенными методами
public int Main(string[] args)
{
// Создаем несколько объектов и производим их сравнение на идентичность.
// Мы специально присваиваем одинаковые значения переменным-членам для целей
// тестирования метода Equals()
Person p1 = new Person("Fred", "Jones", "222-22-2222", 98);
Person p2 = new Person("Fred", "Jones", "222-22-2222", 98);
// Используем замещенный для сравнения внутреннего состояния метод Equals()
if(p1.Equals(p2) && p1.GetHashCode() = = p2.GetHashCode())
Console.WriteLine ("P1 and P2 have same state\n");
else
Console.WriteLine ("P1 and P2 are DIFFERENT\n");
// Теперь меняем внутреннее состояние p2
p2.age = 2;
// Производим сравнение заново:
if(p1.Equals(p2) && p1.GetHashCode() = = p2.GetHashCode())
Console.WriteLine ("P1 and P2 have same state\n");
else
Console.WriteLine ("P1 and P2 are DIFFERENT\n");
// Теперь используем замещенный метод ToString()
Console.WriteLine(p1.ToString());
Console.WriteLine(p2); // Вообще-то, метод WriteLine() вызывает метод
// ToString() автоматически
return 0;
}
18

19. Статические члены System.Object

Person p3 = new Person("Sally", "Jones","333", 4);
Person p4 = new Person("Sally", "Jones","333", 4);
//
Одинаково ли внутреннее состояние p3 и p4? Да!
Console.WriteLine("\n\nP3 and P4 have same state: {0}",
object.Equals(p3, p4));
//
Представляют ли они один и тот же объект в ОП? Нет!
Console.WriteLine("P3 and P4 are pointing to same object: {0}",
object.ReferenceEquals(p3, p4));
19

20. Стандартные типы данных

Типы данных CLS
20

21. Системные типы данных и псевдонимы C#

Диапазон
C#
CLS
System
sbyte
–
SByte
byte
+
Byte
0 … 255
short
+
Int16
–32 768 … 32 767
ushort
–
UInt16
iny
+
Int32
uint
–
UInt32
long
+
Int64
ulong
–
UInt64
char
+
Char
float
+
Single
1.5×10–45 … 3.4×10+38 (32-битовое вещественное (7 знаков))
double
+
Double
5.0×10–324 … 1.7×10+308 (64-битовое вещественное (7
знаков))
bool
+
Boolean
true или false
decimal
+
Decimal
100 … 10+28 (96-битовое целое)
string
+
String
Ограничено только системной памятью
object
+
Object
Практически всё, что угодно
–128 … 127
0 … 65 535
–2 147 483 648 … 2 147 483 647
0 … 4 294 967 295
–9 223 372 036 854 775 808 … 9 223 372 036 854 775 807
0 … 18 446 744 073 709 551 615
U+0000 … U+ffff
21

22. Работа с системными типами

using System;
class MyDataTypes
{
public static int Main(string[] args)
{
// Работаем с UInt16 как со структурным типом
System.UInt16 myUInt16 = 30000;
Console.WriteLine("Max for an UInt16 is: {0}", UInt16.MaxValue);
Console.WriteLine("Min for an UInt16 is: {0}", UInt16.MinValue);
Console.WriteLine("Your value is: {0}", myUInt16.ToString());
Console.WriteLine("I am a: {0}", myUInt16.GetType().ToString());
// Почти то же самое, но уже используем псевдоним C# ushort
// для типа System.Uint16
ushort myOtherUInt16 = 12000;
Console.WriteLine("\nYour value is: {0}", myOtherUInt16.ToString());
Console.WriteLine("I am a: {0}", myOtherUInt16.GetType().ToString());
return 0;
}
}
22

23. Заметки о типах данных

• Вольница с типом bool закончилась
• string, char (в Unicode)
• Нет типов char *, LPSTR, wchar_t * и т.п.
23

24. Упаковка и распаковка от структурного типа к ссылочному и наоборот

// Создаем переменную типа short и присваиваем ей значение
short s = 25;
// Упаковываем переменную s
object objShort = s;
(boxing)
// Распаковка объекта
short anotherShort = (short) objShort;
24

25. Исключение при распаковке в неподходящий тип данных

// Неверная распаковка!
public static int Main(string[] args)
{
...
try
{
// Мы пытаемся распаковать в тип данных string объект,
// исходный тип данных для которого — short!
string str = (string)objShort;
}
catch(InvalidCastException e)
{
Console.WriteLine("OOPS!\n{0}", e.ToString());
}
...
}
25

26.

class MyDataTypes
{
public static void Foo(object o)
{
Console.WriteLine(o.GetType());
Console.WriteLine(o.ToString());
Console.WriteLine("Value of o is: " + o);
}
public static int Main(string[] args)
{ short s = 25; // Make a simple value.
Console.WriteLine("short s = {0}", s);
Console.WriteLine("short is a: {0}\n", s.GetType().ToString());
object objShort = s; // Box the value into a reference.
Console.WriteLine("Boxed object is a: {0}\n", objShort.GetType().ToString());
// Now, unbox the reference back into a short:
short anotherShort = (short)objShort;
Console.WriteLine("short anotherShort = {0}", anotherShort);
Console.WriteLine("Unboxed object is a: {0}",anotherShort.GetType().ToString());
try
{
// Bad unboxing!
// The type contained in the box is NOT a string, but a short!
string str = (string)objShort;
}
catch(InvalidCastException e)
{
Console.WriteLine("\nOOPS!\n{0}", e.ToString());
}
Console.WriteLine("\n\nThe Auto Box");
int x = 99;
Foo(x);
return 0;
}
}
// Auto-box.
26

27. Значения по умолчанию для встроенных типов данных

• При создании класс всем переменнымчленам присваиваются значения по
умолчанию
• Но переменные, описанные внутри метода,
не инициализируются
27

28. Инициализация переменных внутри классов

• public static void Main()
{
int localInt; // Ошибка компилятора
Console.Writeline(localInt.ToString());
}
• public static void Main()
{
int localInt = 0;
Console.Writeline(localInt.ToString());
}
28

29. Константы

using System;
class MyConstants
{
// Эти константы определены на уровне класса
public const int myIntConst = 5;
public const string myStringConst = "I'm a const";
public static void Main()
{
// Эта константа определена на уровне метода
const string localConst = "I am a rock, I am an island";
// А теперь мы применяем константы (обратите внимание на указание
// диапазона, в котором они были созданы).
Console.WriteLine("myIntConst = {0}\nmyStringConst = {1}",
MyConstants.myIntConst,
MyConstants.myStringConst);
Console.WriteLine("Local constant: {0}", localConst);
}
}
29

30. Константы

// Чтобы запретить создание экзепляров данного класса, достаточно
// определить конструктор как private.
class MyConstants
{
// Некоторые константы
public const int myIntConst = 5;
public const string myStringConst = "I'm a const";
// А теперь запретим пользователю создавать экземпляры данного класса,
// ведь единственное назначение этого класса — хранить константы
private MyConstants(){}
}
// Определив класс как абстрактный, мы запрещаем создание
// экземпляров этого класса.
abstract class MyConstants
{
// Некоторые константы
public const int myIntConst = 5;
public const string myStringConst = "I'm a const";
}
30

31. Управляющие конструкции C#

31

32. Циклы в C#

for
foreach/in
while
do/while
32

33. for

public static int Main(string[ ] args)
{
// Переменная i видна только внутри for
for (int i; i<10; i++)
{
Console.WriteLine(“Number is: {0}”,i);
}
return 0; // здесь i уже не видна
}
33

34. foreach / in

// Обрабатываем все элементы массива, используя "foreach"
public static int Main(string[] args)
{
string[] arrBookTitles = new String[] {"Complex Algorithms",
"COM for the Fearful Programmer",
"Do you Remember Classic COM?",
"C# and the .NET platform",
"COM for the Angry Engineer"};
int COM = 0, NET = 0;
// Считаем, что книг по COM и .NET (охватывающих оба предмета) пока не существует
foreach (string s in arrBookTitles)
{
if (-1 != s.IndexOf("COM"))
COM++;
else if(-1 != s.IndexOf(".NET"))
NET++;
}
Console.WriteLine("Found {0} COM references and {1} .NET references.", COM, NET);
return 0;
}
34

35. while

try
{
// Это на тот случай, если файла config.win на месте не окажется
// Открываем файл config.win
StreamReader strReader = File.OpenText("C:\config.win");
// Считываем каждую строку и выводим ее на консоль
string strLine;
while(null != (strLine = strReader.ReadLine()));
{
Console.WriteLine(strLine);
}
// Файл необходимо закрыть
strReader.Close();
}
catch(FileNotFoundException e) // Про исключения рассказано далее
{
Console.WriteLine(e.Message);
}
35

36. Оператор if

• string s = “ABC”
if (s.Length) { … } // так теперь нельзя
• // можно только так
if (s.Length != 0) { … }
36

37. switch

class Selections // Пример применения конструкции "switch"
{
public static int Main(string[] args)
{
Console.WriteLine("Welcome to the world of .NET");
Console.WriteLine("1 = C#\n2 = Managed C++ (MC++)\n3 = VB.NET\n");
Console.Write("Please select your implementation language:");
string s = Console.ReadLine();
// Все встроенные типы данных поддерживают статический метод Parse()
int n = int.Parse(s);
switch(n)
{ // C# требует, чтобы каждый вариант (включая "default" — по умолчанию), в котором
// предусмотрены команды для выполнения, содержал выражение выхода "break" или "goto"
case 1:
Console.WriteLine("Good choice! C# is all about managed code.");
break;
case 2: Console.WriteLine("Let me guess, maintaining a legacy system?");
break;
case 3: Console.WriteLine("VB.NET: It is not just for kids anymore...");
break;
default: Console.WriteLine("Well...good luck with that!");
break;
}
return 0;
}
}
37

38. Методы классов

Дополнение
38

39. Определение методов классов Модификаторы доступа

• public – общедоступный метод
• private – доступен только внутри
класса, в котором определен
• protected – доступен из класса и всех
его потомках
• internal – доступен из всех классов
внутри сборки, в которой он определен
39

40. Уровни доступа к методам

class SomeClass
{
// Доступен отовсюду
public void MethodA(){};
// Доступен только из типов данных SomeClass
private void MethodB(){};
// Доступен только из SomeClass и из классов, производных от
// SomeClass (на любом нижестоящем уровне иерархии)
protected void MethodC(){};
// Доступен только из той же самой сборки
internal void MethodD(){};
// Будет действовать как protected или internal
protected internal void MethodE(){};
// Будет считаться protected — по умолчанию
void Method() {};
}
40

41. Статические методы

class mat
{
public static double sqr(double x)
{ return x*x;
}
}
…
public static void Main(string[ ] args)
{
Console.WriteLine(mat.sqr(3.0));
}
41

42. Статические данные

// Обратите внимание на применение ключевого слова "static"
class Airplane
{
// Эта статическая переменная будет совместно использоваться всеми
// объектами Airplane
private static int NumberInTheAir = 0;
public Airplane()
{
NumberInTheAir++;
}
// Метод для получения значения NumberInTheAir через экземпляр
// объекта Airplane
public int GetNumberFromObject() {return NumberInTheAir;}
// Статический метод — для получения значения NumberInTheAir напрямую
// через класс Airplane
public static int GetNumber() {return NumberInTheAir;}
}
42

43. Статические данные

class StaticApp // Экспериментируем со статическими членами
{
public static int Main(string[] args)
{
// Создадим несколько самолетов
Airplane a1 = new Airplane();
Airplane a2 = new Airplane();
// Сколько взлетело самолетов?
Console.WriteLine("Number of planes: {0}", a1.GetNumberFromObject());
Console.WriteLine("Number of planes: {0}", Airplane.GetNumber());
// Добавим самолетов
Airplane a3 = new Airplane();
Airplane a4 = new Airplane();
// А теперь сколько?
Console.WriteLine("Number of planes: {0}", a3.GetNumberFromObject());
Console.WriteLine("Number of planes: {0}", Airplane.GetNumber());
return 0;
}
}
43

44. Статические члены класса Enviroment

// Вот несколько (но далеко не все) полезных статических типов класса Environment
using System;
class SytemSpy
{
public static int Main(string[] args)
{
// Под какой операционной системой мы работаем?
Console.WriteLine("Current OS: {0}", Environment.OSVersion);
// Текущий каталог?
Console.WriteLine("Current Directory: {0}", Environment.CurrentDirectory);
// А теперь выведем список логических дисков:
string[] drives = Environment.GetLogicalDrives();
for(int i = 0; i < drives.Length; i++)
Console.WriteLine("Drive {0} : {1}", i, drives[i]);
// А какая версия платформы .NET у нас используется?
Console.WriteLine("CurrentVeersion of .NET: {0}", Environment.Version);
return 0;
}
}
44

45. Модификаторы для параметров методов

in
out
ref
params
– входной (по умолчанию)
– выходной
– передача по ссылке
– передача набора параметров как
единое целое
45

46. Использование модификатора out

// Значения исходящим параметрам присваиваются вызываемым методом
public void Add(int x, int y, out int ans)
{
ans = x + y;
}
…
// Предположим, что метод Add() определен в классе с именем Methods
public static void Main()
{
...
Methods m = new Methods();
int ans; // Исходное значение присваивать не обязательно
// — значение вскоре присвоит вызываемый метод
// Обратите внимание на использование ключевого слова out
// в синтаксисе вызова метода
m.Add(90, 90, out ans);
Console.WriteLine("90 + 90 = {0}", ans);
}
46

47. Использование модификатора ref

// Метод принимает параметр, передаваемый по ссылке
public void UpperCaseThisString(ref string s)
{
// Возвращаем символьную строку, в которой все буквы станут заглавными
s = s.ToUpper();
}
// Вызываем этот метод через Main()
public static void Main()
{
...
// Используем ключевое слово ref
string s = "Can you really have sonic hearing for $19.00?";
Console.WriteLine("Before: {0}", s);
m.UpperCaseThisString(ref s)
Console.WriteLine("After: {0}", s);
}
47

48. Использование модификатора params

// Метод принимает два физических параметра
public void DisplayArrayOfInts(string msg, params int[] list)
{
Console.WriteLine(msg);
for (int i=0; i<list.length; i++)
Console.WriteLine(list[i]);
}
Первый параметр – символьная строка
Второй параметр – любое количество целых чисел
int[] intArray = new int[3] {10,11,12};
m.DisplayArraysOfInt(“Here is an array of ints”, intArray);
m.DisplayArraysOfInt(“Enjoy these 3 ints”, 1,2,3);
m.DisplayArraysOfInt(“Take some more”, 55,4,983,10432,98,33);
48

49. Использование модификатора params

// Новая разновидность класса Person
class Person
{
private string fullName;
private byte age;
public Person(string n, byte a)
{
fullName = n;
age = a;
}
public void PrintInfo()
{
Console.WriteLine("{0} is {1} years old", fullName, age);
}
}
49

50. Использование модификатора params

// Что же мне пришлют на этот раз?
public void DisplayArrayOfObjects(params object[] list)
{
for (int i=0; i < list.Length; i++)
{
if(list[i] is Person) // Является ли текущий объект в массиве
// объектом класса Person?
{
// Если да, вызываем нужный метод
((Person)list[i]).PrintInfo();
}
else
Console.WriteLine(list[i]);
Console.WriteLine();
}
Person p = new Person("Fred", 93);
m.DisplayArrayOfObjects(777, p, "I really am an instance of System.String");
50

51. Массивы

Arrays
51

52. Работа с массивами

// Массив символьных строк с 10 элементами {0,1,…,9}
string[] booksOnCOM;
booksOnCOM = new string[10];
// Массив символьных строк из 100 элементов {0,1, … , 99 }
string[] booksOnDotNet = new string[100];
booksOnDotNet[0] = "Троелсен";
// Массив символьных строк с 2 элементами {0,1}
string[] booksOnPL1 = new string[2] { "one", "two"} ;
// Так нельзя
int[4] ages = {30,54,4,10}; // Нет слова new – обязательно для
// массива фиксированного размера
// Но так можно (размер массива определяет компилятор),
// без new можно только в этом случае
int[] ages = {20,22,23,0};
52

53. Многомерный массив (прямоугольный)

// Прямоугольный многомерный массив
int[,] myMatrix;
myMatrix = new int[6, 6];
// Заполняем массив 6 на 6:
for (int i = 0; i < 6; i++)
for (int j = 0; j < 6; j++)
myMatrix[i, j] = i*j;
// Выводим элементы многомерного массива на системную консоль
for (int i = 0; i < 6; i++)
{
for (int j = 0; j < 6; j++)
{
Console.Write(myMatrix[i, j] + "\t");
}
Console.WriteLine();
}
53

54. Многомерный массив (ломаный)

// "Ломаный" многомерный массив (массив из массивов). В нашем случае —
// это массив из пяти внутренних массивов разного размера
int[][] myJagArray = new int[5][];
// Создаем "ломаный" массив
for (int i = 0; i < myJagArray.Length; i++)
{
myJagArray[i] = new int[i + 7];
}
// Выводим каждую строку на системную консоль (как мы помним, каждому элементу
// присваивается значение по умолчанию — в нашем случае 0)
for (int i = 0; i < 5; i++)
{
Console.Write("Length of row {0} is {1}:\t", i, myJagArray[i].Length);
for (int j = 0; j < myJagArray[i].Length; j++)
{
Console.Write(myJagArray[i][j] + " ");
}
Console.WriteLine();
}
54

55. Класс System.Array

• BinarySearch() – поиск элемента массива
• Clear() – очищает диапазон элементов
• CopyTo() – копирование элементов из исходного
массива в массив назначения
• GetEnumerator() – возвращает интерфейс IEnumerator
• GetLength(), Length – количество элементов в
указанном измерении и общее количество элементов
• GetLowerBound(), GetUpperBound() – определение
нижней и верхней границы выбранного измерения
• GetValue(), SetValue() – возвращает или устанавливает
значение указнного индекса
• Reverse() – расставляет элементы в обратном порядке
• Sort() – сортирует массив
55

56.

using System;
class Arrays
{
public static int Main(string[] args)
{
// Массив символьных строк
string[] firstNames = new string[5] {"Меркурий","Венера","Земля","Марс","Юпитер"};
// Выводим имена в соответствии с порядком элементов в массиве
Console.WriteLine("Here is the array:");
for (int i = 0; i < firstNames.Length; i++)
Console.Write(firstNames[i] + "\t");
Console.WriteLine();
// Расставляем элементы в обратном порядке при помощи статического метода Reverse()
Array.Reverse(firstNames);
// ...и снова выводим имена
Console.WriteLine("Here is the array once reversed:");
for (int i = 0; i < firstNames.Length; i++)
Console.Write(firstNames[i] + "\t");
Console.WriteLine();
// А теперь вычищаем всех, кроме Юпитера
Console.WriteLine("Cleared out all but one...");
Array.Clear(firstNames, 1, 4);
for (int i = 0; i < firstNames.Length; i++)
Console.Write(firstNames[i] + "\t\n");
return 0;
}
}
56

57. Текстовые строки

strings
57

58. Класс System.String

Length – поиск элемента массива
Concat() – объединяет две строки в одну
CompareTo() – сравнивает две строки
Copy() – создает копию строки
Format() – форматирование строки
Insert() – вставка строки внутрь существующей
PadLeft(), PadRight() – заполнение строки указанными
символами
• Remove(), Replace() – создают копию строки с
указанными изменениями
• ToUpper(), ToLower() – создают копию строки
строчными или прописными буквами
58

59.

// = = и != используются для сравнения значений строковых объектов.
// + используется для операции конкатенации.
public static int Main(string[] args)
{
System.String strObj = "This is a TEST";
string s = "This is another TEST";
// Производим сравнение значений строк
if(s = = strObj)
Console.WriteLine("Same info...");
else
Console.WriteLine("Not the same info...");
// А теперь — операция конкатенации
string newString = s + strObj;
Console.WriteLine("s + strObj = {0}", newString);
// А еще System.String предоставляет в ваше распоряжение индексатор
// для доступа к любому символу массива
for (int k = 0; k < s.Length; k++)
Console.WriteLine("Char {0} is {1}", k, s[k]);
return 0;
}
59

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

\’
\”
\\
\a
\b
\f
\n
\r
\t
\u
\v
\0
апостроф
кавычка
обратный слэш
системное оповещение
вернуться на одну позицию
начать следующую страницу
вставить новую строку
возврат каретки
горизонтальная табуляция
вставить символ Unicode
вертикальная табуляция
пустой символ
string finalString = @"\n\tString file: 'C:\CSharpProjects\Strings\string.cs'";60
Console.WriteLine(finalString);

61. Применение System.Text.StringBuilder

// Вносим изменения в строку? На самом деле нет...
System.String strFixed = "This is how I began life";
Console.WriteLine(strFixed);
string upperVersion = strFixed.ToUpper(); // создание копии строки
Console.WriteLine(strFixed);
Console.WriteLine(upperVersion + "\n\n");
61

62. Применение System.Text.StringBuilder

// Демонстрирует применение класса StringBuilder
using System;
using System.Text;
// Здесь живет StringBuilder!
class StringApp
{
public static int Main(string[] args)
{
// Создаем объект StringBuilder и изменяем его содержимое
StringBuilder myBuffer = new StringBuilder("I am a buffer");
myBuffer.Append(" that just got longer...");
Console.WriteLine(myBuffer);
return 0;
}
}
62

63. Применение System.Text.StringBuilder

// Продолжаем демонстрировать применение класса StringBuilder
using System;
using System.Text; // Здесь живет StringBuilder
class StringApp
{
public static int Main(string[] args)
{
StringBuilder myBuffer = new StringBuilder("I am a buffer");
myBuffer.Append(" that just got longer...");
Console.WriteLine(myBuffer);
myBuffer.Append("and even longer.");
Console.WriteLine(myBuffer);
// Делаем все буквы прописными
string theReallyFinalString = myBuffer.ToString().ToUpper();
Console.WriteLine(theReallyFinalString);
return 0;
}
}
63

64. Перечисления

Enumerations
64

65. Перечисления

enum EmpType
{
Manager,
Grunt,
Contractor,
VP
}
//
//
//
//
enum EmpType
{
Manager = 10,
Grunt =1,
Contractor = 100
VP = 99
}
=
=
=
=
0
1
2
3
enum EmpType
{
Manager = 102,
Grunt,
// = 103
Contractor, // = 104
VP
// = 105
}
enum EmpType : byte
{
Manager = 10,
Grunt =1,
Contractor = 100
VP = 99
}
65

66.

using System;
class EnumClass
{
public static void AskForBonus(EmpType e)
{
switch(e){
case EmpType.Contractor:
Console.WriteLine("You are already get enough cash...");
break;
case EmpType.Grunt:
Console.WriteLine("You havve got to be kidding...");
break;
case EmpType.Manager:
Console.WriteLine("How about stock options instead?");
break;
case EmpType.VP:
Console.WriteLine("VERY GOOD, Sir!");
break;
default: break;
}
}
public static int Main(string[] args)
{
// Создаем тип Contractor
EmpType fred;
fred = EmpType.Contractor;
AskForBonus(fred);
return 0;
}
}
66

67.

public static int Main(string[] args)
{
EmpType fred;
fred = EmpType.VP;
EnumClass ec = new EnumClass();
// Получаем тип данных перечисления
Console.WriteLine(Enum.GetUnderlyingType(typeof(EmpType)));
Console.WriteLine("You are a {0}", Enum.Format(typeof(EmpType), fred, "G"));
// Получаем информацию о количестве элементов в перечислении
Array obj = Enum.GetValues(typeof(EmpType));
Console.WriteLine("This enum has {0} members.", obj.Length);
// Выводим имена элементов перечисления и соответсвующие им числовые значения
foreach(EmpType e in obj)
{
Console.Write("String name: {0}", Enum.Format(typeof(EmpType), e, "G"));
Console.Write(" ({0})", Enum.Format(typeof(EmpType), e, "D"));
Console.Write(" hex: {0}\n", Enum.Format(typeof(EmpType), e, "X"));
}
// Есть ли в EmpType элемент SalesPerson?
if(Enum.IsDefined(typeof(EmpType), "SalesPerson"))
Console.WriteLine("Yep, we have sales people.");
else
Console.WriteLine("No, we have no profits....");
// Какому их этих двух переменных-членов перечисления соответствует большее числовое значение
EmpType Joe = EmpType.VP;
EmpType Fran = EmpType.Grunt;
if(Joe < Fran)
Console.WriteLine("Joe's value is less than Fran's");
else
Console.WriteLine("Fran's value is less than Joe's");
return 0;
}
67

68. Структуры

Дополнение
68

69. Особенности структур C#

// Для структур можно определить конструкторы, но все
// созданные вами конструкторы должны принимать параметры
struct EMPLOYEE
{
// Поля
public EmpType title;
public string name;
public short deptID;
// Конструктор
public EMPLOYEE (EmpType et, string n, short d)
{
title = et;
name = n;
deptID = d;
}
}
69

70. Особенности структур C#

class StructTester
{
// Создаем Мэри и присваиваем ей значения
// при помощи конструктора
public static int Main(string[] args)
{
// Для вызова нашего конструктора мы обязаны
// использовать ключевое слово new
EMPLOYEE mary = new EMPLOYEE(EmpType.VP, "Mary", 10);
...
return 0;
}
}
70

71. Использование структур в качестве параметров

public void DisplayEmpStats(EMPLOYEE e)
{
Console.WriteLine("Here is {0} \'s info:", e.name);
Console.WriteLine("Department ID: {0}", e.deptID);
Console.WriteLine("Title: {0}",
Enum.Format(typeof(EmpType), e.title, "G"));
}
…
StructTester t = new StructTester();
t.DisplayEmpStats(mary);
t.DisplayEmpStats(fred);
…
71

72. Еще раз об упаковке и распаковке

// Создаем и упаковываем нового сотрудника
EMPLOYEE stan = new EMPLOYEE(EmpType.Grunt, "Stan", 10);
object stanInBox = stan; // это уже ссылочный тип
…
public void UnboxThisEmployee(object o)
{
EMPLOYEE temp = (EMPLOYEE)o;
Console.WriteLine(temp.name + " is alive!");
}
…
// Передаем упакованного сотрудника на обработку
t.UnboxThisEmployee(stanInBox);
// C# при необходимости производит упаковку автоматически
t.UnboxThisEmployee(stan);
72

73. Пространства имен

Namespaces
73

74. Определение пространства имен

// shapeslib.cs – все классы в одном файле
namespace MyShapes
{
using System;
// Класс Circle
public class Circle { // Интересные методы }
// Класс Hexagon
public class Hexagon { // Более интересные методы }
// Класс Square
public class Square
{ // Еще более интересные методы }
}
74

75. Определение пространства имен в нескольких файлах

// circle.cs
namespace MyShapes
{
using System;
// Класс Circle
class Circle { // Интересные методы }
}
// hexagon.cs
namespace MyShapes
{
using System;
// Класс Hexagon
class Hexagon { // Более интересные методы }
}
// square.cs
namespace MyShapes
{
using System;
// Класс Square
class Square { // Еще более интересные методы }
}
75

76. Использование пространства имен

// Используем объекты, определенные в другом пространстве имен
namespace MyApp
{
using System;
using MyShapes;
class ShapeTester
{
public static void Main()
{
// Все эти объекты были определены в пространстве имен MyShapes
Hexagon h = new Hexagon();
Circle c = new Circle();
Square s = new Square();
}
}
}
76

77. Применение пространств имен для разрешения конфликтов между именами классов

// В коде есть двусмысленности!
namespace MyApp
{
using System;
using MyShapes;
using My3DShapes;
// Еще одно пространство имен для
// геометрических фигур
namespace My3DShapes
{ class Circle{}
// Класс 3D Circle
class Hexagon{}
// Класс 3D Hexagon
class Square{}
// Класс 3D Square
}
class ShapeTester
{
public static void Main()
{
// Неизвестно, к объектам какого пространства имен мы обращаемся
Hexagon h = new Hexagon();
Circle c = new Circle();
Square s = new Square();
}
}
77

78. Применение пространств имен для разрешения конфликтов между именами классов

// Конфликтов больше нет
public static void Main()
{
My3DShapes.Hexagon h = new My3DShapes.Hexagon();
My3DShapes.Circle c = new My3DShapes.Circle();
MyShapes.Square s
= new MyShapes.Square();
}
78

79. Использование псевдонимов для имен классов

namespace MyApp
{
using System;
using MyShapes;
using My3DShapes;
// Создаем псевдоним для класса из другого пространства имен
using The3DHexagon = My3DShapes.Hexagon;
class ShapeTester
{
public static void Main()
{
// Создаем объект при помощи псевдонима
The3DHexagon h2 = new The3DHexagon();
}
}
}
79

80. Вложенные пространства имен

// Классы для геометрических фигур расположены в пространстве
// имен Lecture2Types.My3DShapes
namespace Lecture2Types
{
namespace My3DShapes
{
using System;
// Класс 3D Circle
class Circle{}
// Класс 3D Hexagon
class Hexagon{}
// Класс 3D Square
class Square{}
}
}
80

81. C# и объектно-ориентированное программирование

Тема следующей лекции
C# и объектноориентированное
программирование
81