Exemplo n.º 1
0
        static void Main(string[] args)
        {
            int w1 = 5;
            int w2 = 6;

            //Создание экземпляра делегата на основе метода
            Console.WriteLine("На основе метода:");
            PlusOrMinus f1 = new PlusOrMinus(Plus);

            SumOrSubstraction(w1, w2, f1);

            PlusOrMinus f2 = Minus;

            SumOrSubstraction(w1, w2, f2);

            //Использование лямбда-выражение
            Console.WriteLine("\nИспользование лямбда-выражение:");
            SumOrSubstraction(4, 5, (lhs, rhs) => lhs + rhs);


            //Использование Func
            Console.WriteLine("\nBльзование Func:");
            SumOrSubstractionF(4, 5, Minus);
            Console.ReadLine();
        }
Exemplo n.º 2
0
        /// <summary>
        /// Использование делегата
        /// </summary>
        static void PlusOrMinusMethod(string str, int i1, int i2, PlusOrMinus
                                      PlusOrMinusParam)
        {
            int Result = PlusOrMinusParam(i1, i2);

            Console.WriteLine(str + Result.ToString());
        }
Exemplo n.º 3
0
 private void button_plus_or_minus_Click(object sender, EventArgs e)
 {
     if (!kiemtra)
     {
         chuoi1 = PlusOrMinus.plusorminus(chuoi1);
     }
     else
     {
         chuoi2 = PlusOrMinus.plusorminus(chuoi2);
     }
     hienthi();
 }
        private void HandleClick(object sender, RoutedEventArgs e, PlusOrMinus plusOrMinus)
        {
            bool changed = false;;
            int  _delta  = 0;

            // if current value is not null
            if (_value.HasValue)
            {
                if (plusOrMinus == PlusOrMinus.Minus)
                {
                    // if it was a decrement, make sure it is not below min
                    if ((_value.Value - _minus) < _min)
                    {
                        // if so, return the min
                        _delta = _value.Value - _min;
                        _value = _min;
                    }
                    else
                    {
                        // otherwise decrement by minus factor
                        _value -= _minus;
                        changed = true;
                        _delta  = _minus;
                    }
                    _delta *= -1; // we will be adding to the value, so minus is just an add of a negative
                }
                else
                {
                    // it was an increment, make sure it is not greater than max
                    if ((_value.Value + _plus) > _max)
                    {
                        // if so, return the max
                        _delta = _max - _value.Value;
                        _value = _max;
                    }
                    else
                    {
                        // otherwise increment by plus factor
                        _value += _plus;
                        changed = true;
                        _delta  = _plus;
                    }
                }
            }
            tbNumber.Text = _value.ToString();
            if (_clickHdlr != null && changed && _value.HasValue)
            {
                _clickHdlr(_parentContext, _delta);
            }
        }
Exemplo n.º 5
0
        static void Main(string[] args)
        {
            PlusOrMinus pm = new PlusOrMinus(Plus);

            PlusOrMinusUse1("Это целое число", 1, 1.5, true, Plus);
            PlusOrMinusUse1("Это целое число", 1, 1.5, true, (x, y, flag) =>
            {
                if (flag == true)
                {
                    return((int)(x - y));
                }
                else
                {
                    return(x - y);
                }
            }
                            );
        }
Exemplo n.º 6
0
        private static QMatrix PlusOrMinusMatrix(QMatrix a, QMatrix b, PlusOrMinus Calculation)
        {
            if ((object)a == null || (object)b == null)
            {
                throw new NullReferenceException("The object is null. Initialize the matrix");
            }
            if (a.columns != b.columns || a.rows != b.rows)
            {
                throw new MatrixException("Matrices must have the same number of columns and rows");
            }
            QMatrix matrix = new QMatrix(a.rows, a.columns);

            for (int i = 0; i < matrix.rows; i++)
            {
                for (int j = 0; j < matrix.columns; j++)
                {
                    matrix[i, j] = Calculation(a[i, j], b[i, j]);
                }
            }
            return(matrix);
        }
Exemplo n.º 7
0
        private static Matrix PlusOrMinusMatrix(Matrix first, Matrix second, PlusOrMinus Calculation)
        {
            if (first == null || second == null)
            {
                throw new MatrixException("Matrix is not initialized");
            }
            if (first.Col != second.Col || first.Row != second.Row)
            {
                throw new MatrixException("Matrices must have the same number of columns and rows.");
            }
            Matrix matrix = new Matrix(first.Row, second.Col);

            for (int i = 0; i < matrix.Row; i++)
            {
                for (int j = 0; j < matrix.Col; j++)
                {
                    matrix[i, j] = Calculation(first[i, j], second[i, j]);
                }
            }
            return(matrix);
        }
Exemplo n.º 8
0
        static void Main(string[] args)
        {
            int i1 = 3;
            int i2 = 2;

            PlusOrMinusMethod("Плюс: ", i1, i2, Plus);
            PlusOrMinusMethod("Минус: ", i1, i2, Minus);
            //Создание экземпляра делегата на основе метода
            PlusOrMinus pm1 = new PlusOrMinus(Plus);

            PlusOrMinusMethod("Создание экземпляра делегата на основе метода: ",
                              i1, i2, pm1);
            //Создание экземпляра делегата на основе 'предположения' делегата
            //Компилятор 'пердполагает' что метод Plus типа делегата
            PlusOrMinus pm2 = Plus;

            PlusOrMinusMethod("Создание экземпляра делегата на основе 'предположения' делегата: ", i1, i2, pm2);

            //Создание анонимного метода
            PlusOrMinus pm3 = delegate(int param1, int param2)
            {
                return(param1 + param2);
            };

            PlusOrMinusMethod("Создание экземпляра делегата на основе анонимного метода: ", i1, i2, pm2);

            PlusOrMinusMethod("Создание экземпляра делегата на основе лямбда-выражения: ", i1, i2,
                              (int x, int y) =>
            {
                int z = x + y;
                return(z);
            }
                              );
            //Для обобщённого делегата
            PlusOrMinusMethodFunc("Создание экземпляра делегата на основе метода: ", i1, i2, Minus);
            PlusOrMinusMethodFunc("Создание экземпляра делегата на основе лямбда-выражения 3:", i1, i2, (x, y) => x - y);

            Console.ReadKey();
        }
        static void Main(string[] args)
        {
            int i1 = 3;
            int i2 = 2;

            PlusOrMinusMethod("+: ", i1, i2, Plus);
            PlusOrMinusMethod("_: ", i1, i2, Minus);
            //Создание экземпляра делегата на основе метода
            PlusOrMinus pm1 = new PlusOrMinus(Plus);

            PlusOrMinusMethod("Delegate instance creation based on method  : ",
                              i1, i2, pm1);
            //Создание экземпляра делегата на основе 'предположения' делегата
            //Компилятор 'пердполагает' что метод Plus типа делегата
            PlusOrMinus pm2 = Plus;

            PlusOrMinusMethod("Delegate instance creation based on delegate assumption :", i1, i2, pm2);
            Console.WriteLine("Anonymous method : ");
            //Создание анонимного метода
            PlusOrMinus pm3 = delegate(int param1, int param2)
            {
                return(param1 + param2);
            };

            PlusOrMinusMethod("Delegate instance creation based on anonymous method : ", i1, i2, pm2);
            PlusOrMinusMethod("Delegate instance creation based on lambda function : ", i1, i2,
                              (int x, int y) =>
            {
                int z = x + y;
                return(z);
            }
                              );
            Console.WriteLine("Generalized method : ");
            //Для обобщённого делегата
            PlusOrMinusMethodFunc("Delegate instance creation based on method : ", i1, i2, Minus);
            PlusOrMinusMethodFunc("Delegate instance creation based on lambda function :", i1, i2, (x, y) => x - y);

            Console.ReadKey();
        }
Exemplo n.º 10
0
        static void Main(string[] args)
        {
            int    i1 = 3;
            double i2 = 2.5;

            PlusOrMinusMethod("Плюс: ", i1, i2, Plus);


            //Создание экземпляра делегата на основе метода
            PlusOrMinus pm1 = new PlusOrMinus(Plus);

            PlusOrMinusMethod("Создание экземпляра делегата на основе метода: ", i1, i2, pm1); /// Вызов метода



            //Лямбда-выражение в виде переменной
            PlusOrMinus pm2 = (int x, double y) =>
            {
                double z = x + y;
                return(z);
            };
            double test = pm2(1, 2);

            PlusOrMinusMethod("Создание экземпляра делегата на основе лямбда-выражения в виде переменной: ", i1, i2, pm2);/// Вызов метода


            ////////////////////////////////////////////////////////////////
            Console.WriteLine("\n\nИспользование обощенного делегата Func<>");

            PlusOrMinusMethodFunc("Создание экземпляра делегата на основе метода: ", i1, i2, Plus);

            PlusOrMinusMethodFunc("Создание экземпляра делегата на основе лямбда-выражения 3: ", i1, i2, (x, y) => x + y);


            Console.ReadLine();
        }
Exemplo n.º 11
0
        static void Main(string[] args)
        {
            int i1 = 3;
            int i2 = 2;

            PlusOrMinusMethod("Плюс: ", i1, i2, Plus);
            PlusOrMinusMethod("Минус: ", i1, i2, Minus);

            //Создание экземпляра делегата на основе метода
            PlusOrMinus pm1 = new PlusOrMinus(Plus);

            PlusOrMinusMethod("Создание экземпляра делегата на основе метода: ", i1, i2, pm1);

            //Создание экземпляра делегата на основе 'предположения' делегата
            //Компилятор 'пердполагает' что метод Plus типа делегата
            PlusOrMinus pm2 = Plus;

            PlusOrMinusMethod("Создание экземпляра делегата на основе 'предположения' делегата: ", i1, i2, pm2);

            //Создание анонимного метода
            PlusOrMinus pm3 = delegate(int param1, int param2)
            {
                return(param1 + param2);
            };

            PlusOrMinusMethod("Создание экземпляра делегата на основе анонимного метода: ", i1, i2, pm2);

            PlusOrMinusMethod("Создание экземпляра делегата на основе лямбда-выражения 1: ", i1, i2,
                              (int x, int y) =>
            {
                int z = x + y;
                return(z);
            }
                              );

            PlusOrMinusMethod("Создание экземпляра делегата на основе лямбда-выражения 2: ", i1, i2,
                              (x, y) =>
            {
                return(x + y);
            }
                              );

            PlusOrMinusMethod("Создание экземпляра делегата на основе лямбда-выражения 3: ", i1, i2, (x, y) => x + y);



            ////////////////////////////////////////////////////////////////
            Console.WriteLine("\n\nИспользование обощенного делегата Func<>");

            PlusOrMinusMethodFunc("Создание экземпляра делегата на основе метода: ", i1, i2, Plus);

            string OuterString = "ВНЕШНЯЯ ПЕРЕМЕННАЯ";

            PlusOrMinusMethodFunc("Создание экземпляра делегата на основе лямбда-выражения 1: ", i1, i2,
                                  (int x, int y) =>
            {
                Console.WriteLine("Эта переменная объявлена вне лямбда-выражения: " + OuterString);
                int z = x + y;
                return(z);
            }
                                  );

            PlusOrMinusMethodFunc("Создание экземпляра делегата на основе лямбда-выражения 2: ", i1, i2,
                                  (x, y) =>
            {
                return(x + y);
            }
                                  );

            PlusOrMinusMethodFunc("Создание экземпляра делегата на основе лямбда-выражения 3: ", i1, i2, (x, y) => x + y);


            //////////////////////////////////////////////////////////////
            //Групповой делегат всегда возвращает значение типа void
            Console.WriteLine("Пример группового делегата");
            Action <int, int> a1    = (x, y) => { Console.WriteLine("{0} + {1} = {2}", x, y, x + y); };
            Action <int, int> a2    = (x, y) => { Console.WriteLine("{0} - {1} = {2}", x, y, x - y); };
            Action <int, int> group = a1 + a2;

            group(5, 3);

            Action <int, int> group2 = a1;

            Console.WriteLine("Добавление вызова метода к групповому делегату");
            group2 += a2;
            group2(10, 5);
            Console.WriteLine("Удаление вызова метода из группового делегата");
            group2 -= a1;
            group2(20, 10);

            Console.ReadLine();
        }
Exemplo n.º 12
0
        ////////////////////////////////////////////////////////////////////////////

        static void Main(string[] args)
        {
            ////////////////////////////////////////////////////////////////////////
            Console.WriteLine("\nДЕЛЕГАТЫ\n");

            int i1 = 3; int i2 = 2; PlusOrMinusMethod("Плюс: ", i1, i2, Plus); PlusOrMinusMethod("Минус: ", i1, i2, Minus);

            // Создание экземпляра делегата на основе метода
            PlusOrMinus pm1 = new PlusOrMinus(Plus);

            PlusOrMinusMethod("Создание экземпляра делегата на основе метода: ", i1, i2, pm1);

            // Создание экземпляра делегата на основе 'предположения' делегата
            // Компилятор 'пердполагает' что метод Plus типа делегата
            PlusOrMinus pm2 = Plus;

            PlusOrMinusMethod("Создание экземпляра делегата на основе 'предположения' делегата: ", i1, i2, pm2);

            // Создание анонимного метода
            PlusOrMinus pm3 = delegate(int param1, int param2)
            {
                return(param1 + param2);
            };

            PlusOrMinusMethod("Создание экземпляра делегата на основе анонимного метода: ", i1, i2, pm2);
            PlusOrMinusMethod("Создание экземпляра делегата на основе лямбдавыражения 1: ", i1, i2,
                              (int x, int y) =>
            {
                int z = x + y;
                return(z);
            });
            PlusOrMinusMethod("Создание экземпляра делегата на основе лямбдавыражения 2: ", i1, i2, (x, y) => { return(x + y); });
            PlusOrMinusMethod("Создание экземпляра делегата на основе лямбдавыражения 3: ", i1, i2, (x, y) => x + y);

            Console.WriteLine("\nИспользование обощенного делегата Func<>");

            PlusOrMinusMethodFunc("Создание экземпляра делегата на основе метода: ", i1, i2, Plus);

            string OuterString = "ВНЕШНЯЯ ПЕРЕМЕННАЯ";

            PlusOrMinusMethodFunc("Создание экземпляра делегата на основе лямбдавыражения 1: ", i1, i2,
                                  (int x, int y) =>
            {
                Console.WriteLine("Эта переменная объявлена вне лямбдавыражения: " + OuterString);
                int z = x + y;
                return(z);
            });
            PlusOrMinusMethodFunc("Создание экземпляра делегата на основе лямбдавыражения 2: ", i1, i2,
                                  (x, y) =>
            {
                return(x + y);
            });
            PlusOrMinusMethodFunc("Создание экземпляра делегата на основе лямбдавыражения 3: ", i1, i2, (x, y) => x + y);

            // Групповой делегат всегда возвращает значение типа void
            Console.WriteLine("Пример группового делегата");
            Action <int, int> a1    = (x, y) => { Console.WriteLine("{0} + {1} = {2}", x, y, x + y); };
            Action <int, int> a2    = (x, y) => { Console.WriteLine("{0} - {1} = {2}", x, y, x - y); };
            Action <int, int> group = a1 + a2;

            group(5, 3);

            Action <int, int> group2 = a1;

            Console.WriteLine("Добавление вызова метода к групповому делегату");
            group2 += a2; group2(10, 5);
            Console.WriteLine("Удаление вызова метода из группового делегата");
            group2 -= a1; group2(20, 10);

            ////////////////////////////////////////////////////////////////////////
            Console.WriteLine("\nРЕФЛЕКСИЯ\n");

            Type t = typeof(ForInspection);

            Console.WriteLine("Тип " + t.FullName + " унаследован от " + t.BaseType.FullName);
            Console.WriteLine("Пространство имен " + t.Namespace);
            Console.WriteLine("Находится в сборке " + t.AssemblyQualifiedName);

            Console.WriteLine("\nКонструкторы:");
            foreach (var x in t.GetConstructors())
            {
                Console.WriteLine(x);
            }

            Console.WriteLine("\nМетоды:");
            foreach (var x in t.GetMethods())
            {
                Console.WriteLine(x);
            }

            Console.WriteLine("\nСвойства:");
            foreach (var x in t.GetProperties())
            {
                Console.WriteLine(x);
            }

            Console.WriteLine("\nПоля данных (public):");
            foreach (var x in t.GetFields())
            {
                Console.WriteLine(x);
            }

            Console.WriteLine("\nСвойства, помеченные атрибутом:");
            foreach (var x in t.GetProperties())
            {
                object attrObj;
                if (GetPropertyAttribute(x, typeof(NewAttribute), out attrObj))
                {
                    NewAttribute attr = attrObj as NewAttribute;
                    Console.WriteLine(x.Name + " - " + attr.Description);
                }
            }

            Console.WriteLine("\nВызов метода:");
            // Создание объекта
            // ForInspection fi = new ForInspection();
            // Можно создать объект через рефлексию
            ForInspection fi = (ForInspection)t.InvokeMember(null, BindingFlags.CreateInstance, null, null, new object[] { });

            // Параметры вызова метода
            object[] parameters = new object[] { 3, 2 };
            // Вызов метода
            object Result = t.InvokeMember("Plus", BindingFlags.InvokeMethod, null, fi, parameters);

            Console.WriteLine("Plus(3,2)={0}", Result);

            Console.ReadLine();
        }
Exemplo n.º 13
0
        static void PlusOrMinusMethod(string str, double i1, double i2, PlusOrMinus PlusOrMinusParam)
        {
            double Result = PlusOrMinusParam(i1, i2);

            Console.WriteLine(str + Result.ToString());
        }
Exemplo n.º 14
0
        //Метод, принимающий разработанный делегат PlusOrMinus
        static void PlusOrMinusMethod(string str, double d1, double d2, PlusOrMinus PlusOrMinusParam)
        {
            double result = PlusOrMinusParam(d1, d2);

            Console.WriteLine(str + result.ToString());
        }
Exemplo n.º 15
0
        static void Main(string[] args)
        {
            Console.WriteLine("\t\t1)Работа с делегатами");
            double d1 = 1.1, d2 = 2;

            Console.WriteLine("Числа: " + d1.ToString() + " и " + d2.ToString());

            Console.WriteLine("\t1.Вызов метода с разработанным делегатом");
            PlusOrMinusMethod("Сумма: ", 1.1, 2, Plus);
            PlusOrMinus pm1 = Minus;//экземпляр делегата

            PlusOrMinusMethod("Разность: ", 1.1, 2, pm1);
            PlusOrMinusMethod("Создание экземпляра делегата на основе лямбда-выражения\n", d1, d2, (x, y) => x + y);

            Console.WriteLine("\t2.Вызов метода с обобщенным делегатом Func");
            PlusOrMinusFunc("Сумма: ", 1.1, 2, Plus);
            Func <double, double, double> pm2 = Minus;//экземпляр делегата

            PlusOrMinusFunc("Разность: ", 1.1, 2, pm2);
            PlusOrMinusMethod("Создание экземпляра делегата на основе лямбда-выражения\n", d1, d2, (x, y) => x + y);

            Console.WriteLine("\t\t2)Работа с рефлексией");

            Console.WriteLine("\t1.Информация о конструкторах, свойствах и методах");
            Type t = typeof(ForInspection);

            Console.WriteLine("Конструкторы:");
            foreach (var x in t.GetConstructors())
            {
                Console.WriteLine(x);
            }
            Console.WriteLine("Свойства:");
            foreach (var x in t.GetProperties())
            {
                Console.WriteLine(x);
            }
            Console.WriteLine("Методы:");
            foreach (var x in t.GetMethods())
            {
                Console.WriteLine(x);
            }

            Console.WriteLine("\t2.Свойства, помеченные атрибутом:");
            foreach (var x in t.GetProperties())
            {
                object attrObj;
                if (GetPropertyAttribute(x, typeof(NewAttribute), out attrObj))
                {
                    NewAttribute attr = attrObj as NewAttribute;
                    Console.WriteLine(x.Name + " - " + attr.Description);
                }
            }

            Console.WriteLine("\t3.Вызов метода класса:");
            ForInspection fi = (ForInspection)t.InvokeMember(null, BindingFlags.CreateInstance, null, null, new object[] { });

            object[] parameters = new object[] { 1.2, 3.5 };
            object   Result     = t.InvokeMember("Plus", BindingFlags.InvokeMethod, null, fi, parameters);

            Console.WriteLine("Plus(1.2,3.5)={0}", Result);

            Console.ReadLine();
        }
Exemplo n.º 16
0
 static void ApplyToConsole(PlusOrMinus func)
 {
     Console.WriteLine(func(10, 24.3));
 }
Exemplo n.º 17
0
        static void Main(string[] args)
        {
            int i1 = 3;
            int i2 = 2;

            PlusOrMinusMethod("Плюс: ", i1, i2, Plus);
            PlusOrMinusMethod("Минус: ", i1, i2, Minus);
            PlusOrMinus pm1 = new PlusOrMinus(Plus);
            PlusOrMinus pm2 = Plus;
            PlusOrMinus pm3 = delegate(int param1, int param2)
            {
                return(param1 + param2);
            };

            PlusOrMinus pm4 = (int x, int y) =>
            {
                int z = x + y;
                return(z);
            };
            int test = pm4(1, 2);

            PlusOrMinusMethod(
                "Создание экземпляра делегата на основе лямбда-выражения 1: ",
                i1,
                i2,
                (int x, int y) =>
            {
                int z = x + y;
                return(z);
            }
                );

            PlusOrMinusMethodFunc(
                "Создание экземпляра делегата на основе метода: ",
                i1,
                i2,
                Plus
                );

            PlusOrMinusMethodFunc(
                "Создание экземпляра делегата на основе лямбда-выражения 3:",
                i1,
                i2,
                (x, y) => x + y
                );


            Action <int, int> a1 = (x, y) =>
            { Console.WriteLine("{0} + {1} = {2}", x, y, x + y); };
            Action <int, int> a2 = (x, y) =>
            { Console.WriteLine("{0} - {1} = {2}", x, y, x - y); };
            Action <int, int> group = a1 + a2;

            group(5, 3);

            Action <int, int> group2 = a1;

            Console.WriteLine("Добавление вызова метода к групповому делегату");
            group2 += a2;
            group2(10, 5);
            Console.WriteLine("Удаление вызова метода из группового делегата");
            group2 -= a1;
            group2(20, 10);

            Console.ReadLine();
        }
Exemplo n.º 18
0
 static void SumOrSubstraction(int lhs, int rhs, PlusOrMinus Fnk)
 {
     Console.WriteLine(($"{lhs} {(lhs + rhs == Fnk(lhs, rhs) ? "+" : "-")} {rhs} = {Fnk(lhs, rhs)}"));
 }
Exemplo n.º 19
0
        static void Main(string[] args)
        {
            // ДЕЛЕГАТЫ
            int i1 = 1;
            int i2 = 2;

            PlusOrMinusMethod("Плюс: ", i1, i2, Plus);
            PlusOrMinusMethod("Минус: ", i1, i2, Minus);

            //Создание экземпляра делегата на основе метода
            PlusOrMinus pm1 = new PlusOrMinus(Plus);

            PlusOrMinusMethod("Создание экземпляра делегата на основе метода: ", i1, i2, pm1);

            //Создание анонимного метода
            PlusOrMinus pm2 = delegate(int param1, int param2){ return(param1 + param2); };

            PlusOrMinusMethod("Создание экземпляра делегата на основе анонимного метода: ", i1, i2, pm2);
            PlusOrMinusMethod("Создание экземпляра делегата на основе лямбда-выражения: ", i1, i2, (x, y) => x - y);

            //Func<>
            Console.WriteLine("\nИспользование обощенного делегата Func<>");
            PlusOrMinusMethodFunc("Создание экземпляра делегата на основе метода: ", i1, i2, Plus);
            PlusOrMinusMethodFunc("Создание экземпляра делегата на основе лямбдавыражения 3: ", i1, i2, (x, y) => x + y);


            // РЕФЛЕКСИЯ

            Type t = typeof(Class1);

            Console.WriteLine("\nКонструкторы:");
            foreach (var x in t.GetConstructors())
            {
                Console.WriteLine(x);
            }
            Console.WriteLine("\nМетоды:");
            foreach (var x in t.GetMethods())
            {
                Console.WriteLine(x);
            }
            Console.WriteLine("\nСвойства:");
            foreach (var x in t.GetProperties())
            {
                Console.WriteLine(x);
            }
            Console.WriteLine("\nСвойства, помеченные атрибутом:");
            foreach (var x in t.GetProperties())
            {
                object attrObj;
                if (GetPropertyAttribute(x, typeof(NewAttribute), out attrObj))
                {
                    NewAttribute attr = attrObj as NewAttribute;
                    Console.WriteLine(x.Name + " - " + attr.Description);
                }
            }

            //Создание объекта через рефлексию
            Console.WriteLine("\nСвойства, помеченные атрибутом:");
            Class1 fi = (Class1)t.InvokeMember(null, BindingFlags.CreateInstance, null, null, new object[] { });

            //Параметры вызова метода
            object[] parameters = new object[] { 1, 2 };
            //Вызов метода
            object Result = t.InvokeMember("Plus", BindingFlags.InvokeMethod, null, fi, parameters);

            Console.WriteLine("Plus(1,2)={0}", Result);

            Console.ReadLine();
        }
Exemplo n.º 20
0
 static void PlusOrMinusMethod(int i1, int i2, PlusOrMinus PlusOrMinusParam)
 {
     PlusOrMinusParam(i1, i2);
 }
Exemplo n.º 21
0
        static void Main(string[] args)
        {
            PlusOrMinus PlusOrMinusParam = (x, y) => { Console.WriteLine("Разность {0} и {1}: {2}", x, y, x - y); };
            int         i1 = 2, i2 = 3;

            Console.WriteLine("С использованием делегатного метода");
            PlusOrMinusMethod(i1, i2, Plus);
            Console.WriteLine("С использованием лямбда-выражения");
            PlusOrMinusMethod(i1, i2, (x, y) => { Console.WriteLine("Разность {0} и {1}: {2}", x, y, x - y); });
            Console.WriteLine("С использованием Action");
            PlusOrMinusMethodAct(i1, i2, Minus);
            Reflection.ForInspection obj = new Reflection.ForInspection();
            Type t = obj.GetType();

            Console.WriteLine("\nИнформация о типе:");
            Console.WriteLine("Тип " + t.FullName + " унаследован от " +
                              t.BaseType.FullName);
            Console.WriteLine("Пространство имен " + t.Namespace);
            Console.WriteLine("Находится в сборке " + t.AssemblyQualifiedName);
            Console.WriteLine("\nКонструкторы:");
            foreach (var x in t.GetConstructors())
            {
                Console.WriteLine(x);
            }
            Console.WriteLine("\nМетоды:");
            foreach (var x in t.GetMethods())
            {
                Console.WriteLine(x);
            }
            Console.WriteLine("\nСвойства:");
            foreach (var x in t.GetProperties())
            {
                Console.WriteLine(x);
            }
            Console.WriteLine("\nПоля данных (public):");
            foreach (var x in t.GetFields())
            {
                Console.WriteLine(x);
            }
            Console.WriteLine("\nСвойства, помеченные атрибутом:");
            foreach (var x in t.GetProperties())
            {
                object attrObj;
                if (GetPropertyAttribute(x, typeof(Reflection.NewAttribute), out attrObj))
                {
                    Reflection.NewAttribute attr = attrObj as Reflection.NewAttribute;
                    Console.WriteLine(x.Name + " - " + attr.Description);
                }
            }
            Console.WriteLine("\nВызов метода:");
            //Создание объекта
            //ForInspection fi = new ForInspection();
            //Можно создать объект через рефлексию
            Reflection.ForInspection fi =
                (Reflection.ForInspection)t.InvokeMember(
                    null, BindingFlags.CreateInstance,
                    null, null, new object[] { });
            //Параметры вызова метода
            object[] parameters = new object[] { 3, 2 };
            //Вызов метода
            object Result =
                t.InvokeMember("Plus", BindingFlags.InvokeMethod, null, fi, parameters);

            Console.WriteLine("Plus(3,2)={0}", Result);
        }
Exemplo n.º 22
0
        static void Main(string[] args)
        {
            Console.WriteLine("ДЕЛЕГАТЫ\n");

            int i1 = 10, i2 = 5;

            PlusOrMinusMethod("Плюс ", i1, i2, Plus);
            PlusOrMinusMethod("Минус ", i1, i2, Minus);

            PlusOrMinus useMethod  = new PlusOrMinus(Plus);

            PlusOrMinusMethod("Используем метод ", i1, i2, useMethod);


            PlusOrMinus useIdea    = Plus;

            PlusOrMinusMethod("Используем \"предположение\" компилятора ", i1, i2, useIdea);

            PlusOrMinus anonMethod = delegate(int param1, int param2)
            {
                return(param1 + param2);
            };

            PlusOrMinusMethod("Используем анонимный метод ", i1, i2, anonMethod);
            PlusOrMinusMethod("Используем лямбду 0 ", i1, i2,
                              (int x, int y) =>
            {
                int z = x + y;
                return(z);
            });
            PlusOrMinusMethod("Используем лямбду 1 ", i1, i2, (x, y) => { return(x + y); });
            PlusOrMinusMethod("Используем лямбду 2 ", i1, i2, (x, y) => x + y);

            Console.WriteLine("\nИспользуем делегат Func<>");

            PlusOrMinusMethodFunc("Используем метод Plus ", i1, i2, Plus);

            string strOutside      = "sample text";

            PlusOrMinusMethodFunc("Используем лямбду 0\n", i1, i2,
                                  (int x, int y) =>
            {
                Console.WriteLine("\nПеременная вне лямбды " + strOutside);
                int z = x + y;
                return(z);
            });
            PlusOrMinusMethodFunc("\nИспользуем лямбду 2\n", i1, i2,
                                  (x, y) =>
            {
                return(x + y);
            });
            PlusOrMinusMethodFunc("\nИспользуем лямбду 3\n", i1, i2, (x, y) => x + y);

            Console.WriteLine("\nИспользуем групповой делегат");
            Action <int, int> a1    = (x, y) => { Console.WriteLine("{0} + {1} = {2}", x, y, x + y); };
            Action <int, int> a2    = (x, y) => { Console.WriteLine("{0} - {1} = {2}", x, y, x - y); };
            Action <int, int> group = a1 + a2;

            group(10, 5);

            Action <int, int> group2 = a1;

            Console.WriteLine("Добавление вызова метода к групповому делегату");
            group2 += a2; group2(10, 5);
            Console.WriteLine("Удаление вызова метода из группового делегата");
            if ((group2 != null) && (a1 != null))
            {
                group2 -= a1;
            }
            group2(20, 10);

            Console.WriteLine("\nРЕФЛЕКСИЯ\n");

            Type t = typeof(ReflectionObserver);

            Console.WriteLine("Тип " + t.FullName + " унаследован от " + t.BaseType.FullName);
            Console.WriteLine("Пространство имен " + t.Namespace);
            Console.WriteLine("Находится в сборке " + t.AssemblyQualifiedName);

            Console.WriteLine("\nКонструкторы:");
            foreach (var x in t.GetConstructors())
            {
                Console.WriteLine(x);
            }

            Console.WriteLine("\nПубличные методы");
            foreach (var x in t.GetFields())
            {
                Console.WriteLine(x);
            }

            Console.WriteLine("\nМетоды:");
            foreach (var x in t.GetMethods())
            {
                Console.WriteLine(x);
            }

            Console.WriteLine("\nСвойства");
            foreach (var x in t.GetProperties())
            {
                Console.WriteLine(x);
            }

            Console.WriteLine("\nСвойства с атрубутами");
            foreach (var x in t.GetProperties())
            {
                object attrObj;
                if (GetPropertyAttribute(x, typeof(CustomAttribute), out attrObj))
                {
                    CustomAttribute attr = attrObj as CustomAttribute;
                    Console.WriteLine(x.Name + " - " + attr.Description);
                }
            }
            Console.WriteLine("InvokeMember");
            ReflectionObserver fi = (ReflectionObserver)t.InvokeMember(null, BindingFlags.CreateInstance, null, null, new object[] { });

            Console.WriteLine("InvokeMethod");
            object[] parameters = { 10, 5 };
            object   Result     = t.InvokeMember("Plus", BindingFlags.InvokeMethod, null, fi, parameters);

            Console.WriteLine("Plus(10,5)={0}", Result);

            Console.ReadLine();
        }
Exemplo n.º 23
0
        /// Использование делегата

        static void PlusOrMinusMethod(string str, int i1, double i2, PlusOrMinus PlusOrMinusParam) /// Метод, принимающий разработанный мною делегат
        {
            double Result = PlusOrMinusParam(i1, i2);

            Console.WriteLine(str + Result.ToString());
        }
Exemplo n.º 24
0
        static public void PlusOrMinusMethod(string str, int i1, int i2, PlusOrMinus PlusOrMinusParam)        /// Использование делегата
        {
            int Result = PlusOrMinusParam(i1, i2);

            Console.WriteLine(str + Result.ToString());
        }