Tabla de contenido
- Lección 28 Funciones anónimas
- Lección 30 Expresiones y cierres Lambda
- Lección 32 Clasificación de listas
-
- 1. Escribe una clase de monstruo, crea 10 monstruos y agrégalos a la Lista. Ordena la Lista según los números ingresados por el usuario: 1. Clasificación de ataque 2. Clasificación de defensa 3. Clasificación de HP 4. Inversa
- 2. Escriba una clase de artículo (tipo, nombre, calidad), cree 10 artículos, agréguelos a la Lista y compárelos usando tipo, calidad y nombre. El peso de clasificación es: tipo> calidad> longitud del nombre
- 3. Intente utilizar el método de clasificación de Lista para ordenar el contenido del Diccionario. Consejo: Obtenga toda la información del par clave-valor del Diccionario y guárdela en la Lista.
- Lección 34 Covarianza y contravarianza
- Lección 36 Subprocesos múltiples
- Lección 38 Comandos de preprocesamiento
Lección 28 Funciones anónimas
1. Escriba una función que pase un número entero y devuelva una función. Cuando la función anónima se ejecuta más tarde, el número entero se pasa y se multiplica por el número pasado por la función anterior para devolver el resultado.
static Func<int, int> Fun01(int num)
{
return delegate (int a)
{
return a * num;
};
}
Llamada a función principal:
Func<int,int> test = Fun01(4);
Console.WriteLine(test(5));
Lección 30 Expresiones y cierres Lambda
1. Hay una función que devuelve una función delegada. Solo hay un código de impresión en esta función delegada. Cuando se ejecuta la función delegada devuelta, se pueden imprimir del 1 al 10.
static Func<Action> LambdaTest()
{
return () =>
{
Action action =null;
Console.WriteLine("打印代码");
for (int i = 1; i < 11; i++)
{
int index = i;
action += () =>
{
Console.Write(index);
};
}
return action;
};
}
Llamada a función principal:
Func<Action> test = LambdaTest();
test()();
Lección 32 Clasificación de listas
1. Escribe una clase de monstruo, crea 10 monstruos y agrégalos a la Lista. Ordena la Lista según los números ingresados por el usuario: 1. Clasificación de ataque 2. Clasificación de defensa 3. Clasificación de HP 4. Inversa
Crea una clase de monstruo:
class Monister
{
public int att;
public int def;
public int hp;
public Monister(int att,int def,int hp)
{
this.att = att;
this.def = def;
this.hp = hp;
}
public void ShowInfo()
{
Console.WriteLine("怪物的攻击力为：{0}，防御力为：{1}，血量为：{2}",att,def,hp);
}
}
Se llama a la función principal, aquí solo se demuestra la clasificación de ataques:
List<Monister> monisters = new List<Monister>();
Random r = new Random();
for (int i = 0; i < 10; i++)
{
monisters.Add(new Monister(r.Next(1, 100), r.Next(1, 100), r.Next(1, 100)));
}
monisters.Sort((a,b)=>
{
//此处是按照攻击力排序，其他排序只需更改此处即可，为了节省时间。此处省略
return a.att > b.att ? -1 : 1;
});
foreach (var item in monisters)
{
item.ShowInfo();
}
2. Escriba una clase de artículo (tipo, nombre, calidad), cree 10 artículos, agréguelos a la Lista y compárelos usando tipo, calidad y nombre. El peso de clasificación es: tipo> calidad> longitud del nombre
Clase de datos del artículo:
class ItemList
{
public int type;
public string name;
public int quality;
public ItemList(int type,string name,int quality)
{
this.type = type;
this.name = name;
this.quality = quality;
}
public void ShowItemInfo()
{
Console.WriteLine("物品的类型是：{0}，品质是：{1}，名字是：{2}",type,quality,name);
}
}
Llamada a función principal:
List<ItemList> itemLists = new List<ItemList>();
Random r = new Random();
for (int i = 0; i < 10; i++)
{
itemLists.Add(new ItemList(r.Next(1, 5), "" + i + "" + r.Next(100, 100000), r.Next(1, 10)));
}
itemLists.Sort((a, b) =>
{
if (a.type != b.type)
{
return a.type > b.type ? 1 : -1;
}
if (a.quality != b.quality)
{
return a.quality > b.quality ? 1 : -1;
}
return a.name.Length > b.name.Length ? 1 : -1;
});
foreach (var item in itemLists)
{
item.ShowItemInfo();
}
resultado de la operación:
物品的类型是：1，品质是：3，名字是：136130
物品的类型是：1，品质是：4，名字是：760853
物品的类型是：2，品质是：1，名字是：349943
物品的类型是：2，品质是：1，名字是：261133
物品的类型是：2，品质是：3，名字是：919746
物品的类型是：2，品质是：6，名字是：020356
物品的类型是：2，品质是：7，名字是：419499
物品的类型是：3，品质是：1，名字是：587941
物品的类型是：3，品质是：4，名字是：832324
物品的类型是：4，品质是：7，名字是：672702
3. Intente utilizar el método de clasificación de Lista para ordenar el contenido del Diccionario. Consejo: Obtenga toda la información del par clave-valor del Diccionario y guárdela en la Lista.
Dictionary<int, string> dic = new Dictionary<int, string>();
dic.Add(2, "456");
dic.Add(6, "564");
dic.Add(1, "456");
dic.Add(4, "156453");
dic.Add(3, "15343");
dic.Add(5, "12233");
List<KeyValuePair<int, string>> list = new List<KeyValuePair<int, string>>();
foreach (KeyValuePair<int, string> item in dic)
{
list.Add(item);
}
list.Sort((a, b) =>
{
return a.Key > b.Key ? 1 : -1;
});
for (int i = 0; i < list.Count; i++)
{
Console.WriteLine(list[i].Key + "_" + list[i].Value);
}
Lección 34 Covarianza y contravarianza
1. Describa el papel de la covarianza y la contravarianza.
(Referencia aquí@Aries en abril)
//请描述协变逆变有什么作用
//是用来修饰泛型替代符的 泛型委托和泛型接口中
//1.out修饰的泛型类型 只能作为返回值类型 协变
// in修饰的泛型类型 只能作为参数类型 逆变
//2.遵循里氏替换原则 用out和in修饰的泛型委托 如果类型是父子关系 那么可以相互装载
// 协变： 父类泛型委托容器可以装 子类泛型委托容器
// 逆变： 子类泛型委托容器可以装 父类泛型委托容器
2. Explique el papel de la covarianza y la contravarianza a través del código.
//通过代码说明协变和逆变的作用
//协变
delegate T TestOut<out T>();
//逆变
delegate void TestIn<in T>(T v);
class Father
{
}
class Son:Father
{
}
class Program
{
static void Main(string[] args)
{
//协变 代码
TestOut<Son> ts = () =>
{
return new Son();
};
TestOut<Father> tf = ts;
Father f = tf();
//逆变 代码
TestIn<Father> tif = (value) =>
{
};
TestIn<Son> tis = tif;
tis(new Son());
}
}
Lección 36 Subprocesos múltiples
1. Implementación del movimiento de serpientes en Snake.
enum E_MoveDir
{
Up,
Down,
Right,
Left,
}
class Icon
{
//当前移动的方向
public E_MoveDir dir;
//当前位置
public int x;
public int y;
public Icon(int x, int y, E_MoveDir dir)
{
this.x = x;
this.y = y;
this.dir = dir;
}
//移动
public void Move()
{
switch (dir)
{
case E_MoveDir.Up:
y -= 1;
break;
case E_MoveDir.Down:
y += 1;
break;
case E_MoveDir.Right:
x += 2;
break;
case E_MoveDir.Left:
x -= 2;
break;
}
}
//绘制
public void Draw()
{
Console.SetCursorPosition(x, y);
Console.Write("■");
}
//擦除
public void Clear()
{
Console.SetCursorPosition(x, y);
Console.Write(" ");
}
//转向
public void ChangeDir(E_MoveDir dir)
{
this.dir = dir;
}
}
Llamada a función principal:
Console.CursorVisible = false;
icon = new Icon(10, 5, E_MoveDir.Right);
icon.Draw();
//开启多线程
Thread t = new Thread(NewThreadLogic);
t.IsBackground = true;
t.Start();
while (true)
{
Thread.Sleep(500);
icon.Clear();
icon.Move();
icon.Draw();
}
void NewThreadLogic()
{
while (true)
{
switch (Console.ReadKey(true).Key)
{
case ConsoleKey.W:
icon.ChangeDir(E_MoveDir.Up);
break;
case ConsoleKey.A:
icon.ChangeDir(E_MoveDir.Left);
break;
case ConsoleKey.S:
icon.ChangeDir(E_MoveDir.Down);
break;
case ConsoleKey.D:
icon.ChangeDir(E_MoveDir.Right);
break;
}
}
Lección 38 Comandos de preprocesamiento
1. Nombra al menos 4 directivas de preprocesador
//请说出至少4种预处理器指令
//#define 定义一个符号 （没有值的变量）
//#undef 取消定义一个符号
//#if
//#elif
//#else
//#endif
//#warning
//#error
2. Utilice las instrucciones del preprocesador para escribir una función para calcular dos números. Cuando es la versión Unity5, se calcula la suma, pero cuando se usa la versión Unity2017, se calcula la resta y ninguno devuelve 0.
static int Calc(int a, int b)
{
#if Unity5
return a + b;
#elif Unity2017
return a * b;
#elif Unity2020
return a - b;
#else
return 0;
#endif
}