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();
}
/// <summary>
/// Использование делегата
/// </summary>
static void PlusOrMinusMethod(string str, int i1, int i2, PlusOrMinus
PlusOrMinusParam)
{
int Result = PlusOrMinusParam(i1, i2);
Console.WriteLine(str + Result.ToString());
}
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);
}
}
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);
}
}
);
}
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);
}
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);
}
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();
}
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();
}
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();
}
////////////////////////////////////////////////////////////////////////////
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();
}
static void PlusOrMinusMethod(string str, double i1, double i2, PlusOrMinus PlusOrMinusParam)
{
double Result = PlusOrMinusParam(i1, i2);
Console.WriteLine(str + Result.ToString());
}
//Метод, принимающий разработанный делегат PlusOrMinus
static void PlusOrMinusMethod(string str, double d1, double d2, PlusOrMinus PlusOrMinusParam)
{
double result = PlusOrMinusParam(d1, d2);
Console.WriteLine(str + result.ToString());
}
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();
}
static void ApplyToConsole(PlusOrMinus func)
{
Console.WriteLine(func(10, 24.3));
}
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();
}
static void SumOrSubstraction(int lhs, int rhs, PlusOrMinus Fnk)
{
Console.WriteLine(($"{lhs} {(lhs + rhs == Fnk(lhs, rhs) ? "+" : "-")} {rhs} = {Fnk(lhs, rhs)}"));
}
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();
}
static void PlusOrMinusMethod(int i1, int i2, PlusOrMinus PlusOrMinusParam)
{
PlusOrMinusParam(i1, i2);
}
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);
}
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();
}
/// Использование делегата
static void PlusOrMinusMethod(string str, int i1, double i2, PlusOrMinus PlusOrMinusParam) /// Метод, принимающий разработанный мною делегат
{
double Result = PlusOrMinusParam(i1, i2);
Console.WriteLine(str + Result.ToString());
}
static public void PlusOrMinusMethod(string str, int i1, int i2, PlusOrMinus PlusOrMinusParam) /// Использование делегата
{
int Result = PlusOrMinusParam(i1, i2);
Console.WriteLine(str + Result.ToString());
}
