Главная Обратная связь

Дисциплины:

Архитектура (936)
Биология (6393)
География (744)
История (25)
Компьютеры (1497)
Кулинария (2184)
Культура (3938)
Литература (5778)
Математика (5918)
Медицина (9278)
Механика (2776)
Образование (13883)
Политика (26404)
Правоведение (321)
Психология (56518)
Религия (1833)
Социология (23400)
Спорт (2350)
Строительство (17942)
Технология (5741)
Транспорт (14634)
Физика (1043)
Философия (440)
Финансы (17336)
Химия (4931)
Экология (6055)
Экономика (9200)
Электроника (7621)






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



 

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

namespace Nasl22

{

class mas1

{ // класс mas1 будет в дальнейшем использован в качестве типа данных

protected int[] a;

public mas1()

{ // конструктор

int n;

Console.Write("Elements ");

n = Convert.ToInt32(Console.ReadLine());

a = new int[n];

}

public void inpt()

{ // ввод массива

for (int i = 0; i < a.Length; i++)

{

Console.Write("a[" + i + "]=");

a[i] = Convert.ToInt32(Console.ReadLine());

}

}

int sum()

{ // нахождение суммы

int s=0;

for(int i=0;i<a.Length;i++)

s+=a[i];

return s;

}

public int summa

{ // свойство

get { return sum(); }

}

public int this[int k]

{ // индексатор

get { return a[k];}

set { a[k] = value; }

}

}

class cl_a

{

public mas1 arr1; //объявим переменную типа класс mas1

int sm;

public cl_a()

{ // конструктор класса cl_a, он создает и экземпляр mas1

arr1 = new mas1();

arr1.inpt();

}

public int st1()

{ // обращение к свойству класса mas1

sm=arr1.summa;

return sm;

}

}

class Program

{

static void Main(string[] args)

{

cl_a my = new cl_a();

int n, m,r;

n = my.arr1.summa; //обращение к свойству

r = my.st1(); //обращение к собственной функции,

// которая в свою очередь обращается к свойству класса mas1

m = my.arr1[2]; // работает индексатор

Console.WriteLine("Сумма=" + n + " Сумма="+

r+" элемент [2] =" + m);

Console.ReadLine();

} } }

 

Следующий пример иллюстрирует использование класса в качестве типа данных при работе с функциями: введем пары «имя – шифр» и выведем имя, соответствующее максимальному значению шифра (предположим, что оно единственное). Наличие обеих строк: инициализация массива и инициализация каждого элемента массива в цикле обязательно!

namespace FunKlass

{

class dan

{ // этот класс будем использовать в качестве типа данных

public string s1;

public int k;

}

class Program

{

static dan[] fun2()

{ // функция определения количества элементов dan в массиве ,

// инициализация и ввод массива.

int n,m;

dan []w;

Console.Write("Элементов ? ");

n = Convert.ToInt32(Console.ReadLine());

w = new dan[n]; // инициализируем массив



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

{

w[i] = new dan(); // инициализируем элемент массива

Console.Write("Элемент " + i + " Имя ");

w[i].s1 = Console.ReadLine();

Console.Write("Элемент " + i + " Номер ");

w[i].k=Convert.ToInt32(Console.ReadLine());

}

return w;

}

static dan fun1(dan[] x)

{

string t1;

int max=0;

dan d1=new dan();

for (int i = 0; i < x.Length; i++)

{

if (max < x[i].k)

{

max = x[i].k;

d1 = x[i];

}

}

return d1;

}

 

 

static void Main(string[] args)

{

dan []b;

dan otv;

b = fun2(); //ввод массива классов

otv = fun1(b); // обработка массива классов

Console.WriteLine("Number= " + otv.k + " Name= " + otv.s1);

Console.ReadLine();

} } }

 

Можно использовать и следующие реализации класса dan и функции fun2.

class dan

{

public string s1;

public int k;

public dan()

{

Console.Write("Element String ");

s1 = Console.ReadLine();

Console.Write("Element number ");

k = Convert.ToInt32(Console.ReadLine());

}

}

static dan[] fun2()

{

int n,m;

dan []w;

Console.Write("Elements ? ");

n = Convert.ToInt32(Console.ReadLine());

w = new dan[n];

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

{ // каждый элемент вводится конструктором

w[i] = new dan();

}

return w;

}

 

Работа со структурами

 

Класс является ссылочным типом: доступ к его объектам осуществляется с помощью ссылок. Доступ к объектам класса с помощью ссылок вызывает дополнительные накладные расходы при каждом доступе. При работе с маленькими объектами дополнительные расходы могут иметь существенное значение. С целью решения этой проблемы в C# введены структуры. Структура подобна классу, но она имеет тип значение, но не ссылка. Внешне объявление структуры похоже на объявление класса. Структуры могут иметь в своем составе данные, методы, индексаторы, свойства. Конструкторы тоже разрешены, но они обязательно должны иметь параметры; деструкторы – нет. Для создания экземпляра структуры можно вызвать конструктор через new, но можно и не вызывать. В таком случае экземпляр структуры создается, но записанные в конструкторе операции не будут выполнены. Структуры не могут участвовать в процессе наследования, ни в качестве предков, ни в качестве потомков. Исключение: в качестве предка структуры можно указать интерфейс (об интерфейсах поговорим позже).



 

namespace StructFun

{

struct dan1

{

public string s1; // атрибут public обязателен

public int k;

}

class Program

{

static dan1[] inpt()

{ // ввод массива структур

dan1[] temp;

int n;

Console.Write("Elements ? ");

n = Convert.ToInt32(Console.ReadLine());

temp = new dan1[n];

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

{

Console.Write("Elem " + i + " Num ");

temp[i].k = Convert.ToInt32(Console.ReadLine());

Console.Write("Elem " + i + " Name ");

temp[i].s1 = Console.ReadLine();

}

return temp;

}

static double proc1(dan1 []x)

{ // обработка массива структур

int s = 0;

for (int i = 0; i < x.Length; i++)

s += x[i].k;

return (double)s / x.Length;

}

static void Main(string[] args)

{

dan1[] id; // массив исходных данных

double aver;

id = inpt(); // ввод исходных данных

aver = proc1(id); // обработка массива структур

Console.WriteLine("Average=" + aver);

Console.ReadLine();

} } }

 

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

 

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

Создадим в качестве примера базовый класс для обработки массива, вклю­чающий определение массива, его ввод и вывод. К элементам базового класса с атрибутом доступа private нет доступа из классов – наследников, они, таким образом, не наследуются. Поэтому рекомендуют (если нет на этот счет особых соображений) дать элементам базового класса атрибут доступа protected.

class arr

{

protected int[] k; //атрибут доступа protected

//необходим для обеспечения доступа из классов - наследников

public arr()

{ // конструктор 1

int n;

Console.Write("Элементов ? ");

n = Convert.ToInt32(Console.ReadLine());

k = new int[n];

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

{

Console.Write("K[" + i + "]=");

k[i] = Convert.ToInt32(Console.ReadLine());

}

}

public arr(int p)

{ // конструктор 2

k = new int[p];

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

{

Console.Write("K[" + i + "]=");

k[i] = Convert.ToInt32(Console.ReadLine());

}

}

public void output()

{

Console.WriteLine();

Console.WriteLine("Elements of Array");

for (int i = 0; i < k.Length; i++)

Console.WriteLine("K[" + i + "]=" + k[i]);

} }

 

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

 

class proc1 : arr // задаем базовый класс arr

{

int q;

public proc1()

{ // конструктор класса наследника

Console.Write("Граница ");

q = Convert.ToInt32(Console.ReadLine());

}

public int sum()

{

int s = 0;

for (int i = 0; i < k.Length; i++)

if (k[i] > q) s += k[i];

return s;

} }

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

class Program

{

static void Main(string[] args)

{

proc1 My = new proc1(); //1

int s1;

My.output(); // обращение к методу предка

s1=My.sum(); // обращение к собственному методу,

// аналогично можно обращаться и к свойствам предка

Console.WriteLine("Summa= " + s1);

Console.ReadLine();

} }

 

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

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

public proc1(int k1, int k2): base(k1)

{

q = k2;

}

Запись base(k1)означает, что конструктору базового класса в качестве фактического параметра будет передано значение к1. Пример главной функции в этом случае:

 

 

static void Main(string[] args)

{

int s1;

proc1 Myaa = new proc1(6, 20); //обращение к

// конструктору с параметрами

Myaa.output();

s1=Myaa.sum();

Console.WriteLine("Summa= " + s1);

Console.ReadLine();

}

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

 

Ссылки на объекты

 

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

namespace Virtual1

{

class X

{

public int a;

public X(int i) {a=i;}

}

class Y:X

{

public int b;

public Y(int i, int j ): base(i) {b=j;}

}

class Class1

{

static void Main(string[] args)

{

X x1= new X(10);

X x2;

Y y1=new Y(15,100);

int k;

x2=x1; //допустимо, переменные одного типа

Console.WriteLine("First "+x1.a+" Second "+x2.a);

x2=y1; //допустимо, Y наследник X

Console.WriteLine("First "+x1.a+" Second "+x2.a);

 

// k=x2.b;ОШИБКА - класс X не имеет переменной b Console.ReadLine(); } } }

 

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

 

Конструктор копирования

 

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

namespace Construct_Coop

{

class Shape

{

protected double a, h;

public Shape(double x, double y)

{ // обычный конструктор

a = x;

h = y;

}

public Shape(Shape ob)

{ // конструктор копирования

a = ob.a;

h = ob.h;

}

public void NewDan(double x,double y)

{

a = x;

h = y;

}

}

class Tri : Shape

{

protected double area;

public Tri(double x, double y) : base(x, y)

{ // конструктор наследника }

public Tri(Tri ob) :base(ob) // 1

{ // конструктор копирования наследника }

public void Show_area()

{

area = a * h / 2;

Console.WriteLine("S_Treug="+ area);

}

}

class Square : Shape

{

protected double area;

public Square(double x, double y) : base(x, y) { }

public Square(Square ob) : base(ob) { } // 1

public void Show_area()

{

area = a * h;

Console.WriteLine("S_Squar="+ area);

}

}

class Program

{

static void Main(string[] args)

{

Tri my=new Tri(5,12); // работает конструктор

my.Show_area();

Tri w = my; // работает конструктор

w.NewDan(50, 120); // новые данные для w

my.Show_area(); // будут выведены одинаковые значения

w.Show_area();

Tri u = new Tri(w); //работает конструктор копирования

u.NewDan(500, 1200); // новые данные для u

w.Show_area();// будут выведены разные значения

u.Show_area();

Console.ReadLine();

} } }

 

Обратите внимание на строки // 1: в них имеет место присвоение указателю на базовый класс (Shape) ссылки на класс-наследник (Tri, Square).

 

Виртуальные методы

 

Метод, при определении которого присутствует слово virtual, называется виртуальным. Каждый класс - наследник может иметь собственную версию виртуального метода, называется это переопределением и обозначается словом override. В C# выбор версии виртуального метода осуществляется в соответствии со значением указателя на момент вызова (а не типом указателя, как было в § 3.9.). Это делается во время выполнения программы. Указатель во время выполнения программы может указывать на объекты различных классов, поэтому по одному и тому же указателю могут вызываться разные версии виртуального метода. Переопределенные методы обеспечивают поддержку полиморфизма. Полиморфизм позволяет определять в базовом классе методы, которые будут общими для всех наследников, но каждый наследник, в случае необходимости, может иметь их собственные реализации. Естественно, что интерфейсы виртуального метода и всех его версий должны полностью совпадать. Таким образом, применение виртуальных методов позволяет фиксировать интерфейс метода и потом разработать под этот интерфейс новые реализации. Виртуальными могут быть и свойства и индексаторы.

Рассмотрим это на примере.

namespace Virtual1

{

class Shape

{

protected int a,h;

public Shape (int x,int y)

{

a=x;

h=y;

}

publicvirtualvoid Show_area()

{ // вводится виртуальный метод

Console.WriteLine("Площадь будет определен позже");

}

}

class Tri:Shape

{

int s;

public Tri(int x, int y) :base(x, y)

{}

publicoverridevoid Show_area()

{ //первое переопределение виртуального метода

s=a*h/2;

Console.WriteLine("Площадь треугольника= "+s);

}

}

class Square:Shape

{

int s;

public Square(int x, int y):base(x, y)

{}

publicoverridevoid Show_area()

{ // второе переопределение виртуального метода

s=a*h;

Console.WriteLine("Площадь четырехугольника= "+s);

}

}

 

class Class1

{

static void Main(string[] args)

{

Shape q=new Shape(10,30);

q.Show_area();

//

Tri z1=new Tri(5,12);

z1.Show_area();

//

Shape w;

w=z1; // w будет указывать на объект класса Tri

w.Show_area(); // Tri.Show_area()

//

Square w1=new Square(5,12);

w1.Show_area();

//

w=w1; // w будет указывать на объект класса Square

w.Show_area(); //Square.Show_area()

Console.ReadLine();

} } }

 

Как видно из примера, указатель w имеет тип Shape, но он может указывать на все наследники Shape. Выбор версии виртуального метода зависит от значения указателя на момент вызова, поэтому вызову w.Show_area(); соответствуют разные версии Show_area().

 

 

Абстрактные методы и классы

 

В C# существует возможность введения в базовом классе методов, а их реализацию оставить «на потом». Такие методы называют абстрактными. Абстрактный метод автоматически является и виртуальным, но писать это нельзя. Класс, в котором имеется хотя бы один абстрактный метод, тоже называется абстрактным и такой класс может служить только в качестве базового класса. Создать объекты абстрактных классов невозможно, потому что там нет реализации абстрактных методов. Чтобы класс – наследник абстрактного класса не был в свою очередь абстрактным (хотя и это не запрещено), там должны содержаться переопределения всех наследованных абстрактных методов.

Модифицируем приведенный выше пример.

namespace Virtual1

{

abstract class Shape

{ // Создается абстрактный класс,

// наличие abstract обязательно!

public int a,h;

public Shape (int x,int y)

{

a=x;

h=y;

}

public abstract void Show_area();

// реализация не нужна – метод абстрактный,

// фиксируется лишь интерфейс метода

}

class Tri:Shape

{

// см. предыдущий пример,

// наличие publicoverridevoid Show_area() обязательно!

}

class Square:Shape

{

// см. предыдущий пример

// наличие publicoverridevoid Show_area() обязательно!

}

class Class1

{

static void Main(string[] args)

{

Shape q; //указатель на абстрактный класс

// q=new Shape(4,6); это ошибка, нельзя создать объект

// абстрактного класса!

q = new Tri(10,20);

q.Show_area();

q = new Square(10,20);

q.Show_area();

Console.ReadLine();

} } }

 

Указатель на абстрактный класс может указывать на любой класс – наследник.

 

Интерфейсы

 

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

interface имя_интерфейса

{

Тип_возвращаемого_значения имя _1(параметры);

Тип_возвращаемого_значения имя_2(параметры);

. . . . . . . . .

}

 

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

Пример.

namespace Interface1

{

public interface Int1

{ //описание интерфейса из трех методов

double area(double x);

double per();

string type();

}

struct Tri:Int1 //использование интерфейса

{ // структура тоже может быть наследником интерфейса

double a,b,c;

 

// реализации методов интерфейса

public double area(double x)

{double p;

p=(a+b+c)/2;

 

return x*Math.Sqrt(p*(p-a)*(p-b)*(p-c));

}

 

public double per()

{

return a+b+c;

}

 

public string type()

{

return "Treug";

}

 

public Tri(double a1,double b1,double c1)

// конструктор структуры всегда должен иметь параметр(ы)

{

a=a1;

b=b1;

c=c1;

}

}

class Neli:Int1

{ // класс – наследник интерфейса

double a,h;

public Neli(){

a=10;h=5;

}

 

// другая реализация методов интерфейса

public double area(double x)

{

return x*a*h;;

}

public double per()

{

return 2*(a+h);

}

public string type()

{

return "Square";

}

 

}

class Class1

{

static void Main(string[] args)

{

Tri t1=new Tri(4.2,5.6,7.2);

Console.Write("Area={0:####.##}",t1.area(0.8));

Console.WriteLine(" Perim="+t1.per());

 

Neli r1=new Neli();

Console.WriteLine("Area 2 = "+r1.area(1.0)+

" Perim 2 ="+r1.per());

Console.ReadLine();

}

} }

С интерфейсами связана еще одна интересная возможность: интерфейсные ссылки. Можно объявить переменную типа интерфейс, которая затем может ссылаться на любой класс – наследник этого интерфейса. Поэтому главная функция предыдущего примера может иметь следующий вид:

static void Main(string[] args)

{

Int1 xint; // переменная типа интерфейс

 

xint = new Tri(3, 4, 5); // первый вариант

Console.Write("Area={0:####.##}", xint.area(0.8));

Console.WriteLine(" Perim=" + xint.per());

 

Neli r1 = new Neli();

xint = r1; // второй вариант

Console.WriteLine("Area 2 = " + xint.area(1.0)

+ " Perim 2 =" + xint.per());

Console.ReadLine();

}

 

Делегаты и события

 

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

Общий вид объявления делегата:

delegate тип_возвращаемого_значения имя_делегата (список_формальных_параметров);

Для использования делегата должен быть объявлен указатель на делегата

Имя_делегата указатель_на_делегата;

и этот указатель должен быть инициирован.

указатель_на_делегата = new имя_делегата (имя_функции);

Здесь используется только имя функции (параметры не указываются).

 

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

Пример 1. Дополним программу из § 3.12 следующей строкой:

namespace Virtual1

{

delegate void del1();// объявление делегата del1

// далее следует программа из § 3.12

}

Объявленному делегату del1()могут соответствовать толькофункции без формальных параметров и без возвращаемого значения.

 

Главная функция будет иметь вид:

static void Main(string[] args)

{

Shape q, r;

q = new Tri(10,20);

del1 f1 = new del1(q.Show_area);

// объявим переменную типа делегат f1 и ставим ей в соответствие

// функцию Show_area из объекта q класса Tri

//

r = new Square(10,20);

del1 f2 = new del1(r.Show_area);

// объявим переменную типа делегат f2 и ставим ей в соответствие

// функцию Show_area из объекта r класса Square

//

f1(); //идентичен вызову q.Show_area();

f2(); // идентичен вызову r.Show_area();

Console.ReadLine();

}

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

В этом примере переменная типа делегат лишь заменяет имя функции, при этом фиксировано, к какому объекту относится представляемая функция.

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

namespace Deleg

{

delegate double fun1(double x);//объявление делегата

class Test

{

protected double []x;

protected double y=0;

protected int n;

public Test()

{

n=5;

x=new double[n];

for(int i=0;i<x.Length;i++)

{

Console.Write("X["+i+"]=");

x[i]=Convert.ToDouble(Console.ReadLine());

}

}

public void gg(fun1 ff)

// формальный параметр – функция

{

for(int i=0;i<x.Length;i++)

 

y+=(double)ff(x[i]);

// использование формального параметра – функции

 

Console.WriteLine("Summa={0:##.###}",y);

}

public static double w1(double p)

{return Math.Sin(p);}

public double w2(double p)

{return Math.Log(p);}

}

class Class1

{

static void Main(string[] args)

{

Test tt=new Test();

// объявление переменной типа класс Test

fun1 f1=new fun1(Test.w1);

// объявление переменной f1 типа делегат fun1, функция w1

// статическая, поэтому на нее можно ссылаться через имя класса Test

 

tt.gg(f1);

// использование функции в качестве фактического параметра

 

fun1 f2;

f2=new fun1(tt.w2);

// объявление переменной f1 типа делегат fun1, на функцию w2

// можно ссылаться только через имя объекта tt

 

tt.gg(f1);

// использование функции в качестве фактического параметра

 

Console.ReadLine();

} } }

 

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

 

Пример 3. Многоадресный делегат. Одному делегату можно ставить в соответствие несколько функций. В таком случае они будут выполнены в такой последовательности, как они были прикреплены делегату.

 

namespace Deleg_2

{

delegate int Deleg(ref string st); //объявим делегат

class Class1

{

public static int met1(ref string x)

{

Console.WriteLine("I am Metod 1");

x+=" 11111";

return 5;

}

public static int met2(ref string y)

{

Console.WriteLine("I am Metod 2");

y+=" AAAAA";

return 55;

}

static void Main(string[] args)

{

Deleg d1;

int k;

string r="******";

Deleg d2=new Deleg(met1);

// связываем делегат и функцию

Deleg d3=new Deleg(met2);

d1=d2; // присоединим первый делегат

d1+=d3; // добавим второй делегат

k=d1(ref r);

Console.WriteLine(r);

Console.WriteLine("k=" + k);

Console.ReadLine();

} } }

 

 

В качестве ответа получим:

I am Metod 1

I am Metod 2

****** 11111 AAAAA

K=55

 

Как видно из примера, в случае, когда делегат имеет возвращаемое значение (в нашем случае int), значением многоадресного делегата будет значение, возвращенное последней функцией (в нашем случае met2).

Для исключения функции из многоадресного делегата необходимо писать d1-=d3; (вычитать удаляемый делегат, в данном случае d3).

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

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

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

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

 

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

event событийный_делегат объект;

Здесь элемент событийный_делегат означает имя делегата, используемого для поддержки объявляемого события, а элемент объект — это имя создаваемого событийного объекта.

Пример 4:

namespace Event1

{

delegate void MyEvent(); //объявим делегат события

class My

{ // класс события

public event MyEvent activate; //объявим событие activate

public void fire()

{

if(activate!=null)activate();

}

}

class Demo

{

static void handler()

{ // функция – обработчик события

Console.WriteLine("Что-то случилось . . . ");

}

static void Main(string[] args)

{

My evt=new My();

evt.activate+=new MyEvent(handler);

// метод handler регистрируется в качестве обработчика события

evt.fire();

Console.ReadLine();

}

}

}

 

Все события активизируются посредством делегата. Следовательно, событийный делегат определяет сигнатуру для события. В данном случае параметры отсутствуют, однако событийные параметры разрешены. Затем создается класс события My. При выполнении следующей строки кода, принадлежащей этому классу, объявляется событийный объект MyEvent. Кроме того, внутри класса My объявляется метод fire(), который в этой программе вызывается, чтобы сигнализировать о событии (Другими словами, этот метод вызывается, когда происходит событие). Как показано в следующем фрагменте кода, он вызывает обработчик события посредством делегата

if(activate!=null)activate();

Обратите внимание на то, что обработчик события вызывается только в том случае, если делегат activate не равен null-значению. Поскольку другие части программы, чтобы получить уведомление о событии, должны зарегистрироваться, можно сделать так, чтобы метод fire () был вызван до регистрации любого обработчика события. Чтобы предотвратить вызов null-объекта, событийный делегат необходимо протестировать и убедиться в том, что он не равен null-значению. Внутри класса Demo создается обработчик события handler (). В этом примере обработчик события просто отображает сообщение, но ясно, что другие обработчики могли бы выполнять более полезные действия. В методе Main() создается объект класса My, а метод

handler () регистрируется в качестве обработчика этого события. Обратите внимание на то, что обработчик добавляется в список с использованием составного оператора "+=". Следует отметить, что события поддерживают только операторы "+=" и " - = ".

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

Пример 5.

namespace Events2

{

delegate void MyEvent();

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

class My

{

public event MyEvent activate; //определение события

public void fire()

{

if (activate!=null) activate();

}

}

class X

{ // первый обработчик

public void Xhandler()

{

Console.WriteLine("I am X");

}

}

class Y

{

public void Yhandler()

{ // второй обработчик

Console.WriteLine("I am Y");

}

}

class Class1

{

static void handler()

{ // третий обработчик, функция статическая

Console.WriteLine("I am base");

}

static void Main(string[] args)

{

My evt =new My();

X x1= new X();

Y y1=new Y();

evt.activate+=new MyEvent(handler);

// так можно писать, если функция-обработчик статическая

 

evt.activate+=new MyEvent(x1.Xhandler);

evt.activate+=new MyEvent(y1.Yhandler);

//если функция обычная, то ссылка на нее только через объект соответствующего класса

 

evt.fire();

Console.ReadLine();

} } }

 

 

Исключительные ситуации

 

Исключительная ситуация – это нарушение нормального хода выполнения программы в результате ошибки. Обратим наше внимание на случаи, когда имеющиеся в программе операторы по какой-то причине не могут быть выполнены. Элементарные примеры: деление на нуль, выход индекса за границы. Конечно, появление подобных исключительных ситуаций можно предотвратить путем включения в программу условных операторов проверки корректности используемых в операции данных. Но их изобилие удлиняет программу и затрудняет восприятие ее логики. Поэтому современный подход к программированию заключается во включении в программу операторов проверки факта возникновения исключительных ситуаций и их обработки. В C# проверка и обработка исключительных ситуаций реализуется операторами try catch finally.

try {

// Блок кода, подлежащий проверке на наличие ошибок.

}

catch {исключительная_ситуация_l exOb1) {

// Обработчик для исключительная_ситуация_l.

}

catch (исключительная_ситуация_2 exOb2) {

// Обработчик для исключения типа исключительная_ситуация_2.

}

catch {

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

}

finally {

//эта часть программы выполняется всегда

}

 

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

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

 

namespace Exception1

{

class Program

{

static void Main(string[] args)

{

int[] x ={4,64,128,256,516,1024,2048 };

int[] y ={2,0,4,0,6 };

for (int i=0;i<x.Length;i++)

try

{

Console.WriteLine(x[i] + " / " + y[i] + " = " + x[i] / y[i]);

}

catch (DivideByZeroException)

{

Console.WriteLine("Деление на нуль");

}

catch (IndexOutOfRangeException)

{

Console.WriteLine("Индекс за границей");

}

catch

// выполняется, если разновидность exception не установлена

{

Console.WriteLine("Что-то случилось");

}

finally //выполняется всегда

{

Console.WriteLine("Завершение ");

}

Console.WriteLine("Цикл успешно завершен");

Console.ReadLine();

} } }

 

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

 

 

Представим возможность читателю найти ответ на вопрос: каким будет результат работы этой программы, если оператор цикла целиком поместить в блок try ?

Наиболее распространенные исключительные ситуации приведены в таблице.

Исключение   Значение
ArrayTypeMismatchException Тип сохраняемого значения несовместим с типом массива
DivideByZeroException Попытка деления на нуль
IndexOutOfRangeException Индекс массива оказался вне диапазона
InvalidCastException Неверно выполнено динамическое приведение типов
OutOfMemoryException Обращение к оператору new оказалось неудачным из-за недостаточного объема свободной памяти
OverflowException Имеет место арифметическое переполнение
NullReferenceException Была сделана попытка использовать нулевую ссылку, т.е. ссылку, которая не указывает ни на какой объект
StackoverflowException Переполнение стека

 

Исключение NullReferenceException генерируется при попытке использовать нулевую ссылку, например, при попытке вызвать метод, передав ему вместо ссылки на объект нулевую ссылку. Нулевая ссылкане указывает ни на какой объект. Один из способов создать нулевую ссылку — явно присвоить ссылочной переменной null-значение, используя ключевое слово null.

 

Контрольные вопросы

1. Разъясните суть понятий «класс» и «объект».

2. Перечислите и характеризуйте свойства объектно-ориентированного программирования.

3. Какие атрибуты доступа имеются на C#? Как целесообразно их выбирать?

4. Для чего применяется перегрузка операторов? Каковы основные правила перегрузки?

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

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

7. В чем особенности виртуальных методов? Когда целесообразно их использовать?

8. Что такое «абстрактный класс?»

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

 


Эта страница нарушает авторские права

allrefrs.ru - 2019 год. Все права принадлежат их авторам!