Лаба №7. Использование. Клиент-Сервер

Текст программы:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace lab7_cs

{

class Program

{

   class D//клиент

   {

       public D() { Console.WriteLine("Constructor D"); }

       ~D() { }

       public int f()

       {

           this.d = 5;

           return this.d * 2;

       }

       public int F()

       {

           this.d = 15;

           return this.d + 5;

       }

       public int d { set; get; }

   }

 

   class E//сервер

   {

       public E() { Console.WriteLine("Constructor E"); }

       ~E() { }

       public void me(D d) { Console.WriteLine("class E client me() = {0}", d.f()); }

       public void ME(D d) { Console.WriteLine("Class E client ME() = {0}", d.F()); }

   }

   static void Main(string[] args)

   {

       D d = new D();

       E e = new E();

       e.me(d); // клиент(объект d) обращается к ресурсам сервера(класс E) через объект e с помощью метода me.

       e.ME(d);

       Console.ReadKey();

   }

}

}

Результат работы программы:

Вывод:

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

Общность.

Текст программы:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace Lab7_friend

{

class Program

{

   static class D

   {

       //public static D() { }// не может содержать конструкторы

       public static int F() { return 7; } // Содержит только статические член

       //public void f() { Console.WriteLine("Нельзя это использовать в статическом классе..."); }

   }// Статический класс в основном такой же, как и нестатический класс, но имеется одно отличие: нельзя создавать экземпляры статического класса.

   class F

   {

       public static int R() { return 10; } // а так можно в обычном классе использовать статические функции

       private static int F1() { return 1; }

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

   // скрыть их можно с помощью модификатора доступа private

 

   class E

   {

       public E() { }

       ~E() { }

       public void me() { Console.WriteLine("class D function F = {0}", D.F()); }

 

       public void ME() { Console.WriteLine("class F function R = {0}", F.R()); }

   }

   static void Main(string[] args)

   {

       F f = new F();

       E e = new E();

       e.me();

       //нельзя сделать D d = new D();

       D.F();

       Console.WriteLine("class F function R = {0}", F.R());

       e.ME();

 

       //Console.Readkey() — Console - класс. а ReadKey() - статическая функция

       Console.ReadKey();

   }

}

}

Результат работы программы:

Вывод: Использование общности позволяет одному объекту взаимодействовать со всеми методами и членами второго, если первый объект по отношению ко второму объявляется другом. Также, чтобы открыть доступ функциям к данным объекта. они могут быть объявлены дружественными.

 

Лаба №8. Конкретизация.

Текст программы:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace Lab8

{

public interface IA

{

   void F();

}

class A: IA

{

   public void F() { Console.WriteLine("Привет"); }

}

class U<T> where T:class// с помощью where T: class мы можем ограничить тип Т. в данном случае здесь по классу, т.е. в Т можем конкретизировать только классы.

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

{      // при использовании категории использование, он будет выдавать ошибку.

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

   public void F1() { Console.WriteLine("Как дела?"); }

   public U(T t) { this.t = t; }

   public T t { get; set; }

   //IA ia;// = new A();

   public void F()

   {

       Console.WriteLine(t is IA);

       Console.WriteLine(t);// вывод что это вообще за параметр

       if (t is IA)

       {

           IA ia = (IA)t;// делаем преобразование типа к интерфейсу

           ia.F();// вызов функции в классе А F()

       }

 

   }

 

}

class IdAccount<T>

{

   public IdAccount(T name, int Sum) { this._Sum = Sum; this.namet = name; }

   public T namet;

   public int _Sum;

}

class Swap<T>// здесь Т универсальный параметр, он позволяет указать, какой тип здесь будет использоваться

{

   public void FSwap(ref T x, ref T y)

   {

       t = x;

       x = y;

       y = t;

   }

   public T t;

 

}

class Program

{

   static void Main(string[] args)

   {

       Swap<int> swap = new Swap<int>();// здесь мы используем объект типа int

       int x = 5;

       int y = 6;

       Console.WriteLine("x = {0} y = {1}", x, y);

       swap.FSwap(ref x, ref y);// передача параметров по ссылке. при передачи по значению, в метод передается только копия, а здесь передается ссылка на саму переменную в память

       Console.WriteLine("x = {0} y = {1}", x, y);

 

       IdAccount<string> idAccount1 = new IdAccount<string>("Ваня", 5000);

       IdAccount<int> idAccount2 = new IdAccount<int>(15954, 70000);

 

       Console.WriteLine("{0} {1}", idAccount1.namet, idAccount1._Sum);

       Console.WriteLine("{0} {1}", idAccount2.namet, idAccount2._Sum);

 

       A a = new A();

       //Console.WriteLine(a is IA);

       U<A> u = new U<A>(a);// передача по ссылке объекта в конструктор. здесь мы передали класс А в параметр типа.

       //U<A> u = new U<A>();

       //u.t = a;// связываем объекты двух классов u и a.

       u.F();

       Console.ReadKey();

   }

}

}

 

Вывод: Мы конкретизируем классы и функции для работы с объектами, типы которых заранее не определены. С каким(и) именно типам(и) придется работать определяется в момент вызова – имя типа настраивает функцию\класс для работы. Это нужно для повторного использования кода (повышает гранулярность программного кода).

Лаба №9. Анонимные функции.

Делегаты.

Текст программы:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace lab9._1

{

class Program

{

   public delegate void Str(string s);//делегаты - это указатели на методы и с помощью делегатов мы можем вызвать данные методы.

   public delegate int Sum(int x, int y);// сначала идёт ключевое слово delegate, потому тип возращаемого типа, название и параметры в скобках.

   public delegate void Ob();

 

   static void Main(string[] args)

   {

       Str str = null;// создаем переменную делегата

       str = MessageShow;// присваиваем адрес метода

       MessageShow("Привет");// он обратится к статическому методу в этом классе и выведет строчку, т.к. мы передаем в качестве параметра строку

       Sum sum = SumF;

       Console.WriteLine($"SumF(20, 17) = {SumF(20, 17)}");

       Console.WriteLine();

       Ob ob = null;

       ob += Pr;// к этой переменной делегата прибавим строчку для вывода

       ob();// Привет

       Str str1 = new Str(MessageShow);// ещё один способ передачи методов, создание объекта делегата с помощью конструктора в который передается нужный метод

       MessageShow("Как дела");

 

       Console.WriteLine();

       //ob = ob + Ds; // или ob += Ds;

       //ob();// Привет, Всё с тобой понятно, пока.

       //Console.WriteLine();

 

       Ob s = delegate ()// создание анонимного метода

       {//создание анонимного метода начинается с ключевого слова delegate, после которого в скобках передаётся количество параметров и идёт тело метода

           Console.WriteLine("Как погода");

       };

       s();

       Console.WriteLine();

       MessaShow2("Азаза", delegate (string tr)

       {

           Console.WriteLine(tr);

       });

       ob -= Pr;

       Console.WriteLine();

       ob += Ds;

       ob();

       Console.ReadKey();

   }

   public static void MessaShow2(string s, Str str)

   {

       str(s);

   }

   public static void MessageShow(string s)

   {

       Console.WriteLine(s);

   }

   public static int SumF(int x, int y)

   {

       return x + y;

   }

   public static void Pr()

   {

       Console.WriteLine("Помогите");

   }

   public static void Ds()

   {

       Console.WriteLine("Пожалуйста");

   }

}

} Результат работы программы:

Вывод: Для определения делегата используется ключевое слово delegate, после которого идет сигнатура. Для использования делегата объявляется объект этого делегата. Объекту данного класса сигнатур можно присвоить метод со сходной сигнатурой. Для объектов класса сигнатур возможна операция декремента/инкремента. Также можно использовать анонимные делегаты путём объявления объекта класса сигнатур и присваивания ему анонимного метода со сходной у делегата сигнатурой.Делегаты можно передавать в качестве аргументоа методу, что довольно удобно.Использование делегатов позволяет добиться более адекватного моделирования и повторного использования кода.

 

Лямбда-выражения

Текст программы:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace lab9._2

{

class Program

{

   delegate void N();

   delegate string Str(string s);

   delegate int Sum(int x, int y);

   delegate int Sum1(int x);

   delegate int X(ref int x);

 

   static void Main(string[] args)

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

       Sum sum = (x, y) => x + y;// самое простое лямбда выражение. В скобках передается количество параметров, после знака => выолняется блок выражений

       Console.WriteLine($"sum(10,2) = {sum(10, 2)}");// параметры в скобках должны соответствовать типам и количеству параметров в делегате

       Console.WriteLine();

 

       Sum1 sum1 = x => x++;

       Console.WriteLine($"sum1(1) = {sum1(1)}");

       Console.WriteLine();

 

       Str str = (s) => "Ну наконец-то";

       Console.WriteLine(str);

       Console.WriteLine();

 

       N n = () => Console.WriteLine("А эти лямбда выражения прикольные");

       n();

       Console.WriteLine();

 

       N n1 = () => Message();// создали объект n1 который вызывает метод Message()

          n1();              // Ну привет

       Console.WriteLine();

 

       int n2 = 19;

       X x1 = (ref int r) => r++; // при передаче по ссылке нужно указывать и в делегате что мы передаем по ссылке

       Console.WriteLine($"x1(ref n2) = {x1(ref n2)}");

 

 

       List<int> arr = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

       Console.WriteLine(arr.First<int>());// вывод первого элемента массива в листе

       arr.Add(15);

       arr.ForEach(delegate (int i)// использование перебора элементов массива с помощью делегатов и вывод их

       {

           Console.Write($"{i} ");

       });

       arr.ForEach((i) => Console.WriteLine(i));// использование перебора элементов массива с помощью лямбда-выражений и вывод их

 

       Console.ReadKey();

   }

   public static void Message()

   {

       Console.WriteLine("Ну привет");

   }

 

}

}

Результат работы программы:

Вывод: Лямбда-выражения представляют упрощенную запись анонимных методов. Лямбда-выражения позволяют создать емкие лаконичные методы, которые могут возвращать некоторое значение и которые можно передать в качестве параметров в другие методы. Ламбда-выражения имеют следующий синтаксис: слева определяется список параметров, в середине лямбда-оператор =>, а справа блок выражений, использующий эти параметры: (список_параметров) => выражение. Как и делегаты, лямбда-выражения можно передавать в качестве аргументов методу для тех параметров, которые представляют делегат, что довольно удобно. Как и делегаты, лямбда-выражения позволяют добиться повторного использования кода и адекватного моделирования.

 

События.

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

Текст программы:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace lab4_1

{

class Student

{

   public delegate void EventStudentHandler(string s);

   public event EventStudentHandler True;// события объявляются с помощью ключевого слова event, после которого следует тип делегата и потом название события

   public event EventStudentHandler False;

   public event EventStudentHandler Vvod;

   public void vvod()

   {

       if (Vvod!= null)

           Vvod("Введите приветствие на английском языке: ");// определив событие, мы можем вызвать его как метод, используя имя события

   }

   public void TF(string s)

   {

       if (s == "hi" || s == "hello")

       {

           if (True!= null)

           {

               Console.ForegroundColor = ConsoleColor.Blue;// устанавливаем цвет фона на вывод события. Это синий

               True("Это правильно!");

               Console.ResetColor();// сброс цвета

           }               

       }

       else

       {

           if (False!= null)

           {

               Console.ForegroundColor = ConsoleColor.Red;

               False("Это неправильно!");

               Console.ResetColor();

           }

       }

   }

}

class Program

{

   static void Main(string[] args)

   {

       Student student = new Student();

       student.Vvod += Show_Message1; // добавление обработчика события. он добавляется только так: {событие} += {обработчик события}. также и удаление -=

       student.True += Show_Message;// нередко в качестве обработчиков события применяются Методы

       student.False += Show_Message;// каждый обработчик событий должен соответствовать по списку параметров и возвращаемому типу делегата

       for (;;)// здесь он для примера выводов обработчиков

       {

           student.vvod();

           string s = Console.ReadLine();

           if (s == "exit") break;

           student.TF(s);

               

               

       }

       Console.ReadKey();

   }

   public static void Show_Message(string s)

   {

       Console.WriteLine(s);

   }

   public static void Show_Message1(string s)

   {

       Console.Write(s);

   }

}

}

Вывод: События позволяют сигнализируют системе о том, что произошло определенное действие. События объявляются в классе с помощью ключевого слова event, после которого идет название класса сигнатур, для которого объявляется это событие. Обработчик события – это метод, который выполняет некоторые действия в программе, в случае если событие произошло(сгенерировалось).