Методичка по C (Методичка по C#), страница 7
Описание файла
Документ из архива "Методичка по C#", который расположен в категории "". Всё это находится в предмете "системное и прикладное программное обеспечение (сппо)" из 6 семестр, которые можно найти в файловом архиве НИУ «МЭИ» . Не смотря на прямую связь этого архива с НИУ «МЭИ» , его также можно найти и в других разделах. Архив можно найти в разделе "книги и методические указания", в предмете "системное и прикладное программное обеспечение (сппо)" в общих файлах.
Онлайн просмотр документа "Методичка по C"
Текст 7 страницы из документа "Методичка по C"
{ // структура тоже может быть наследником интерфейса
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();
}
3.14. Делегаты и события
Делегат — это объект, который может ссылаться на метод. Во время выполнения программы один и тот же делегат можно использовать для вызова различных методов, просто заменив метод, на который ссылается этот делегат. Таким образом, метод, который будет вызван делегатом, определяется не в период компиляции программы, а во время ее работы. Делегат в 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();
} } }
3.15. Исключительные ситуации
Исключительная ситуация – это нарушение нормального хода выполнения программы в результате ошибки. Обратим наше внимание на случаи, когда имеющиеся в программе операторы по какой-то причине не могут быть выполнены. Элементарные примеры: деление на нуль, выход индекса за границы. Конечно, появление подобных исключительных ситуаций можно предотвратить путем включения в программу условных операторов проверки корректности используемых в операции данных. Но их изобилие удлиняет программу и затрудняет восприятие ее логики. Поэтому современный подход к программированию заключается во включении в программу операторов проверки факта возникновения исключительных ситуаций и их обработки. В C# проверка и обработка исключительных ситуаций реализуется операторами try catch finally.
try {
// Блок кода, подлежащий проверке на наличие ошибок.
