12---Net基础加强
2024-09-22 08:59:10
使用ShowDialog窗体之间的回传值:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms; namespace _02使用ShowDialog窗体之间的回传值
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
} private void button1_Click(object sender, EventArgs e)
{
Form2 f2 = new Form2();
f2.ShowDialog();
MessageBox.Show(f2.userMsg);
MessageBox.Show("OK"); }
}
}
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms; namespace _02使用ShowDialog窗体之间的回传值
{
public partial class Form2 : Form
{
public Form2()
{
InitializeComponent();
} public string userMsg; private void button1_Click(object sender, EventArgs e)
{
this.userMsg = this.textBox1.Text;
this.Close();
}
}
}
作业1：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace _01作业
{
class Program
{
static void Main(string[] args)
{
//Delegate1 md = M1;
//md(10,20,30); Delegate1 md = arr => Console.WriteLine(arr.Length);
md(, , );
Console.ReadKey();
} static void M1(params int[] arr)
{
Console.WriteLine(arr.Length);
}
} public delegate void Delegate1(params int[] array);
}
作业-多播委托
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace _03多播委托
{
class Program
{
static void Main(string[] args)
{
////一个委托同时指向了多个方法，这就是多播委托
//Delegate1 md = M1;
//md += M2;
//md += M3;
//md += M4;
//md += M5;
////md = M6;//如果使用符号为委托赋值，最后会将前面的所有的绑定的委托都覆盖掉 //md -= M3;
//md -= M5; //md();//当调用委托变量的时候，绑定到该委托上的所有方法都会被调用
//Console.ReadKey(); //Delegate1 md = M1;
//md = (Delegate1)Delegate.Combine(md,new Delegate1(M2));
//md = (Delegate1)Delegate.Combine(md, new Delegate1(M3));
//md = (Delegate1)Delegate.Remove(md, new Delegate1(M1)); AddDelegate md = T1;
md += T2;
md += T3;
//多播委托如果方法有返回值的化，这里只能获取最后一个方法的返回值.
//int n=md(100,200);
//Console.WriteLine(n); //获取每个方法被调用后的返回值
Delegate[] mds = md.GetInvocationList();
//循环遍历mds,获取每个委托对象并调用
for (int i = ; i < mds.Length; i++)
{
Delegate mm = mds[i];
int n = ((AddDelegate)mm)(,);
Console.WriteLine(n);
} Console.ReadKey(); } //static int T1(int x,int y)
//{
// return x + y;
//} //static int T2(int x, int y)
//{
// return x + y;
//} //static int T3(int x, int y)
//{
// return x + y;
//} static int T1(int x, int y)
{
return ;
} static int T2(int x, int y)
{
return ;
} static int T3(int x, int y)
{
return ;
} static void M1()
{
Console.WriteLine("M1");
} static void M2()
{
Console.WriteLine("M2");
} static void M3()
{
Console.WriteLine("M3");
} static void M4()
{
Console.WriteLine("M4");
} static void M5()
{
Console.WriteLine("M5");
} static void M6()
{
Console.WriteLine("M6");
}
} public delegate int AddDelegate(int n1,int n2);
//定义一个委托
public delegate void Delegate1();
}
自定义泛型1
泛型类：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace _04自定义泛型
{
class Program
{
static void Main(string[] args)
{
//List<int> list = new List<int>();
//泛型是代码重用和算法重用
//泛型类
//泛型接口
//泛型方法
//泛型委托 //MyClass<string> mc = new MyClass<string>(new string[] { "A", "B", "C"});
MyClass<int> mc = new MyClass<int>(new int[]{ ,,});
mc.Show();
Console.Read(); }
} //T Type
class MyClass<T>
{
public MyClass(T[] _names)
{
this.names = _names;
}
public T[] names = null; public void Show()
{
foreach (T item in names)
{
Console.WriteLine(item);
}
}
} }
泛型方法：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace _04自定义泛型
{
class Program
{
static void Main(string[] args)
{
Person p = new Person();
//p.show<string>("aaaaaaaaaaaa");
//p.show("aaaaaaaaaaaa");//这两种都是正确的 p.show<int>();
Console.ReadKey(); }
} //泛型方法
public class Person
{
//方法后直接写<T>就表示一个泛型方法
public void show<T>(T msg)
{
Console.WriteLine(msg);
}
} }
泛型接口：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace _04自定义泛型
{
class Program
{
static void Main(string[] args)
{
SpiderMan<string> sm = new SpiderMan<string>();
sm.Fly("gdsfgsdfgdsfgdsf");
Console.ReadKey(); }
} //泛型接口
public interface IFlyable<T>
{
void Fly(T msg);
} //实现泛型接口的时候必须指定对应的泛型类型
//编写一个类来实现泛型接口
//一个普通类实现了泛型接口
public class SupperMan:IFlyable<string>
{
#region MyRegion public void Fly(string msg)
{
Console.WriteLine(msg);
}
#endregion
} //一个泛型类实现了泛型接口
public class SpiderMan<YZK> : IFlyable<YZK>
{ public void Fly(YZK msg)
{
throw new NotImplementedException();
}
} //public class SpiderMan<YZK> : IFlyable<string>
//{ // public void Fly(YZK msg)
// {
// throw new NotImplementedException();
// }
//}
}
泛型委托：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace _04自定义泛型
{
public delegate void M1Delegate(string msg);
public delegate void MGenericDelegate<T>(T msg);
class Program
{
static void Main(string[] args)
{
#region 泛型委托 //M1Delegate md = M1;
//md("aaaaaaaaaaaaa");
//Console.ReadKey(); //MGenericDelegate<string> md = M1;
//md("aaaaaaaaaaaaa");
//Console.ReadKey(); //MGenericDelegate<int> md = M2;
//md(123);
//Console.ReadKey(); MGenericDelegate<double> md = M3;
md(123.45);
Console.ReadKey(); #endregion } static void M1(string msg)
{
Console.WriteLine(msg);
}
static void M2(int msg)
{
Console.WriteLine(msg);
}
static void M3(double msg)
{
Console.WriteLine(msg);
}
static void M4(float msg)
{
Console.WriteLine(msg);
}
static void M5(Person msg)
{
Console.WriteLine(msg);
}
} class Person
{ } }
泛型委托：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace _04自定义泛型
{
public delegate void M1Delegate(string msg);
public delegate void MGenericDelegate<T>(T msg);
class Program
{
static void Main(string[] args)
{
#region 系统内置的泛型委托
//只要是Action委托都是无返回值的 ////存储无参数无返回值的方法
//Action md = () => { Console.WriteLine("无参数无返回值。"); };
//md();
//Console.ReadKey(); ////存储有几个参数的返回值
//Action<string,int> md = (s,i) => { Console.WriteLine(s+" "+i); };
//md("aaaaaaaaaaaa",123);
//Console.ReadKey(); //带返回值的方法的时候，就需要使用另外一个泛型委托Func //Func<string> fn = T1;
//string ss = fn();
//Console.WriteLine(ss);
//Console.ReadKey(); ////返回值是string类型，参数是一个int类型
//Func<int, string> fn = n => n.ToString();
//Console.WriteLine(fn(10));
//Console.ReadKey(); ////返回值是string类型，参数是一个int类型
//Func<int,int, string> fn =T2;
//Console.WriteLine(fn(12,5));
//Console.ReadKey(); List<int> list = new List<int>{,,,,,,,,};
//List<int> listresult = list.FindAll(MyFilter);
List<int> listresult = list.FindAll(element=>element>);
//list.Where(a => a > 5);
for (int i = ; i < listresult.Count; i++)
{
Console.WriteLine(listresult[i]);
}
Console.ReadKey(); #endregion }
static bool MyFilter(int element)
{
return element>;
}
static string T1()
{
return "aaaaaaaaaaaaa";
} static string T2(int n1,int n2)
{
return (n1*n2).ToString();
}
} }
泛型约束：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace _05泛型约束
{
class Program
{
static void Main(string[] args)
{
//List<int>list=new List<int>();
//list.Sort(); //List<Person> list = new List<Person>();
//list.Sort(); //MyClass<string> mc = new MyClass<string>();
//MyClass<int> mc = new MyClass<int>(); //MyClass<MyTestClass> mc = new MyClass<MyTestClass>(); MyClass<Person> mc = new MyClass<Person>(); }
} class MyTestClass : IComparable
{ public int CompareTo(object obj)
{
throw new NotImplementedException();
}
}
//class AscByAge : IComparable<Person>
//{ // public int CompareTo(Person x,Person y)
// {
// throw new NotImplementedException();
// }
//} class Person:IComparable<Person>
{
//public Person(string s)
//{ //}
private int _age; public int Age
{
get { return _age; }
set { _age = value; }
} private string _name; public string Name
{
get { return _name; }
set { _name = value; }
} public int CompareTo(Person other)
{
throw new NotImplementedException();
}
} ////使用泛型约束，约束了T只能是值类型
//class MyClass<T> where T:struct
//{ //} ////使用泛型约束，约束了T只能是引用类型不能是值类型
//class MyClass<T> where T : class
//{ //} //限制T必须是实现了某个接口的类型,要求T必须是实现了IComparable接口的子类型对象或者就是该接口类型对象
//class MyClass<T> where T : IComparable
//{ //} ////要求T必须是Person类型或者是Person类的子类型
//class MyClass<T> where T : Person
//{ //} ////要求T必须是Person类型或者是Person类的子类型
//class MyClass<T>
// where T : Person
// where T : new()//要求将来传递进来的类型必须具有一个无参数的构造函数
//{ //} //对T没有要求，但是V必须是T类型或者T类型的子类型
class MyClass<T,V>
where V :T
{ }
}
扩展方法：
先建一个静态类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace _07扩展方法
{
/// <summary>
/// 1.增加扩展方法第一步，增加一个静态类，类名随便起
/// 该静态类应该与将来要用扩展方法的地方在一个命名空间下。
/// 即便命名空间不一样，用的时候也必须导入该命名空间否则不能使用
/// </summary>
static class MethodExt
{
//2.向静态类中增加一个静态方法
//该静态方法的第一个参数就表示要给哪个类型增加该扩展方法
//第一个修饰符this是必须的，这里的obj就表示将来调用该方法的那个
public static void SayHello(this Person obj)
{
Console.WriteLine("Helllo"+obj.Name);
}
}
}
主程序：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace _07扩展方法
{
class Program
{
static void Main(string[] args)
{
Person p = new Person();
p.Name = "叶长种";
p.SayHi(); //扩展方法
p.SayHello();
Console.ReadKey();
}
} class Person
{
public string Name{get;set;}
public void SayHi()
{
Console.WriteLine("Hi~~~~~~~~~~~~");
}
}
}
事件介绍：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace _08事件介绍
{
class Program
{
static void Main(string[] args)
{
Mp3Palyer mp3 = new Mp3Palyer();
mp3.BeforeMusicPlaying = () => { Console.WriteLine("音乐播放之前加载歌曲........."); };
mp3.BeforeMusicStoping = () => { Console.WriteLine("音乐结束之前保存播放进度........."); };
mp3.Start();
mp3.PowerOff();
Console.ReadKey();
}
} /// <summary>
/// Mp3播放器
/// </summary>
public class Mp3Palyer
{
//希望在音乐开始播放之前插入一段代码，这段代码是由将来调用者来指定的
public Action BeforeMusicPlaying; //希望在音乐停止播放之前插入一段代码，这段代码也是由将来调用者来指定的
public Action BeforeMusicStoping; //启动Mp3
public void Start()
{
Console.WriteLine("启动");
if (BeforeMusicPlaying!=null)
{
//在音乐正式播放之前调用该委托
BeforeMusicPlaying();
}
//调用 PlayMusic()方法开始播放音乐
PlayMusic();
} private void PlayMusic()
{
Console.WriteLine("音乐开始播放。。。。。。。。。。");
} //关机
public void PowerOff()
{
if (BeforeMusicStoping != null)
{
//在音乐结束之前调用该委托
BeforeMusicStoping();
}
//调用停止播放音乐的方法
Stop();
} //启动Mp3
public void Stop()
{
Console.WriteLine("音乐停止播放");
}
}
}
事件案例：
创建控件
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms; namespace _09事件案例
{
public partial class UCTripleButton : UserControl
{
public UCTripleButton()
{
InitializeComponent();
} //当在声明委托变量的前面加了event关键字自后，则委托变量就不是委托变量了，就立刻变成了事件
public event Action TripleClick;
int count = ;
//这个是按钮的单击事件
private void button_Click(object sender, EventArgs e)
{
//每次单击一次统计一下
count++;
if (count>=)
{
//MessageBox.Show("点了3次！");
if (TripleClick!=null)
{
//调用一下委托
TripleClick();
} count = ;
}
}
}
}
窗体1：
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms; namespace _09事件案例
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
} //这里是按钮的单击事件
private void button1_Click(object sender, EventArgs e)
{
MessageBox.Show("你好！！！！！");
} //委托可以直接赋值，但是事件不能直接赋值
//事件只能使用+=或者-=来赋值，这样就避免了通过=将之前的注册的事件都覆盖掉
private void Form1_Load(object sender, EventArgs e)
{
//ucTripleButton1.TripleClick = ClickThree;
ucTripleButton1.TripleClick += new Action(ucTripleButton1_TripleClick);
} void ucTripleButton1_TripleClick()
{
Console.WriteLine("事件处理");
}
private void ClickThree()
{
MessageBox.Show("被点击了三次！");
}
}
}
窗体2：
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms; namespace _09事件案例
{
public partial class Form2 : Form
{
public Form2()
{
InitializeComponent();
} private void Form2_Load(object sender, EventArgs e)
{
//ucTripleButton1.TripleClick = Click3;
ucTripleButton1.TripleClick += new Action(ucTripleButton1_TripleClick);
} void ucTripleButton1_TripleClick()
{
Console.WriteLine("事件处理");
}
public void Click3()
{
MessageBox.Show("哇塞！！！！被点击了三次哦！！！");
} }
}
最新文章
- java利用16进制来辨别png格式的图片
- linux中C语言获取高精度时钟gettimeofday函数
- 每天一个linux命令（30）：cal 命令
- HTTP 笔记与总结（3 ）socket 编程：发送 GET 请求
- TQJson序列和还原clientdataset.data
- Python学习 之 数据类型（邹琪鲜 milo）
- 第3组UI组件：AdapterView及其子类
- 身份证js检测
- 猜数字游戏--基于python
- Guava新增集合类型-Multiset
- JS-对象的数据重复
- java实现栈的简单操作
- STM32F1-GPIO的操作
- 报错Error configuring application listener of class org.springframework.web.context.ContextConfigLocation
- IIR数字滤波器的实现（C语言）
- 自制 Chrome Custom.css 设置网页字体为微软雅黑扩展
- Docker镜像的获取和推送
- jmeter数据库查询与接口返回进行对比
- 十天精通CSS3(1)
- SQL Server配置数据库邮件