第一篇文章请到这里:
在此提醒下,本文适合:
文章引用:
- interface IProgram
- {
- void Fun();
- }
- class Program:IProgram
- {
- //显式实现接口成员
- void IProgram.Fun()
- {
- Console.WriteLine("I am Fun.");
- }
- staticvoid Main(string[] args)
- {
- IProgram p =new Program(); //声明一个接口实例,但不是对接口进行实例化
- p.Fun();
- Console.Read();
- }
- }
- interface IProgram
- {
- void Fun();
- }
- interface IAProgram
- {
- void Fun();
- }
- class Program : IProgram, IAProgram
- {
- void IProgram.Fun() //显式实现接口IProgram
- {
- Console.WriteLine("I am IProgram Fun.");
- }
- void IAProgram.Fun() //显式实现接口IAProgram
- {
- Console.WriteLine("I am IAProgram Fun.");
- }
- //public void Fun() //隐式实现接口
- //{
- // Console.WriteLine("I am Program Fun.");
- //}
- staticvoid Main(string[] args)
- {
- //IProgram p = new Program();
- //p.Fun();
- //IAProgram ap = new Program();
- //ap.Fun();
- Program pro =new Program();
- ((IProgram)pro).Fun();
- ((IAProgram)pro).Fun();
- Console.Read();
- }
- }
接口继承和类继承不同
- interface IProgram
- {
- void Fun();
- }
- interface IAProgram:IProgram
- {
- }
- class Program : IAProgram
- {
- void IProgram.Fun()
- {
- Console.WriteLine("I am IProgram Fun.");
- }
- static void Main(string[] args)
- {
- Program pro =new Program();
- ((IAProgram)pro).Fun();
- Console.Read();
- }
- }
- interface IProgram
- {
- void Fun();
- }
- abstract class AProgram : IProgram
- {
- public abstract void AFun();
- void IProgram.Fun()
- {
- AFun();
- }
- }
- class Program:AProgram
- {
- public override void AFun()
- {
- Console.WriteLine("I am AProgram.");
- }
- static void Main(string[] args)
- {
- IProgram pro =new Program();
- pro.Fun();
- Console.Read();
- }
- }
- //结果:I am Aprogram.
通过断点,可以看到,当执行 pro.Fun(); 时,首先会跳到接口的实现方法里,然后去调用抽象函数的实现方法,当抽象函数的方法实现后,再回到接口的实现方法,直到执行完成。
- interface IProgram
- {
- void Fun();
- }
- class AProgram : IProgram
- {
- public virtual void AFun() //注意这里是虚函数
- {
- Console.WriteLine("I am virtual AFun.");
- }
- void IProgram.Fun()
- {
- AFun();
- }
- }
- class Program:AProgram
- {
- public override void AFun() //这里是Override重写
- {
- Console.WriteLine("I am override AFun.");
- }
- static void Main(string[] args)
- {
- IProgram pro =new Program();
- pro.Fun();
- Console.Read();
- }
- }
我们把上面的例子进行改进:
- interface IProgram
- {
- void Fun();
- }
- class AProgram : IProgram
- {
- public virtual void AFun()
- {
- Console.WriteLine("I am virtual AFun.");
- }
- void IProgram.Fun()
- {
- AFun();
- }
- }
- class Program:AProgram
- {
- public new void AFun()
- {
- Console.WriteLine("I am new AFun.");
- }
- static void Main(string[] args)
- {
- Program pro =new Program();
- ((IProgram)pro).Fun();
- pro.AFun();
- Console.Read();
- }
- }
I am virtual AFun.
I am new AFun.
由于前面已经讲过了 ==,这里不在对此进行分析,由此我们可知使用 New 关键字是对其进行隐藏,当对接口实现的方法里调用的是虚方法时,和类的执行过程是一样的。
异:
同:
简述:简单的说,一个是同一个函数的几种形式, 一个是重写父类函数。
区别:
简述:值类型包括简单类型、结构体类型和枚举类型,引用类型包括自定义类、数组、接口、委托等
- using System;
- using System.Text;
- class EventDel
- {
- static void Main(string[] args)
- {
- StringBuilder a=new StringBuilder();//将StringBuilder的一个首地址传给a
- StringBuilder b=a; //将StringBuilder的一个首地址传给b
- b.Append("mxh");
- Console.WriteLine(a);
- a=null;
- Console.WriteLine(b);
- }
- }
输出结果:
mxh
mxh
参考资料 :
委托是一种安全的函数指针,事件是一种消息机制
委托提供了封装方法的方式, 事件是某动作已发生的说明, 事件是建立于委托之上的。
程序运行时同一个委托能够用来调用不同的方法,只要改变它的引用方法即可, 因此委托调节器用的方法不是在编译时决定的, 而是在运行时确定的.
- Global.asax类
- 代码
- using System;
- using System.Collections;
- using System.ComponentModel;
- using System.Web;
- using System.Web.SessionState;
- using System.IO;
- /// Global 的摘要说明。
- public class Global : System.Web.HttpApplication
- {
- /// 必需的设计器变量。
- private System.ComponentModel.IContainer components = null;
- private FileStream fileStream;
- private StreamReader reader;//读字符流
- private StreamWriter writer;//写字符流
- public Global()
- {
- InitializeComponent();
- }
- protected void Application_Start(Object sender, EventArgs e)
- {
- Application["CurrentGuests"]=0;//初始花为0;
- fileStream = File.Open(Server.MapPath("counts.text"),FileMode.OpenOrCreate);//文件不存在,创建文件
- reader = new StreamReader(fileStream);//要读取的完整路径
- Application["AllGuests"] = Convert.ToInt32(reader.ReadLine()); //从当前流中读取一行字符并将数据作为字符串返回
- reader.Close();//关闭流
- }
- protected void Session_Start(Object sender, EventArgs e)//当用户访问网站时,在线用户+1,总访问数+1
- {
- Application.Lock();//同步,避免同时写入
- Application["CurrentGuests"] =(int)Application["CurrentGuests"]+ 1;//总在线用户数
- Application["AllGuests"] =(int)Application["AllGuests"]+ 1;//访问网站的总用户数
- fileStream = new FileStream(Server.MapPath("counts.text"),FileMode.OpenOrCreate,FileAccess.ReadWrite);//
- writer = new StreamWriter(fileStream);//实现一个写入流,使其以一种特定的编码向流中写入字符
- writer.WriteLine(Application["AllGuests"].ToString());//把访问网站的总用户数再次写入到文件
- writer.Close();//关闭写入流
- Application.UnLock();//同步结束
- }
- protected void Session_End(Object sender, EventArgs e)//当前用户退出网站时,在线用户数量-1,
- {
- Application.Lock();
- Application["CurrentGuests"] =(int)Application["CurrentGuests"] - 1;//总在线用户数量-1
- Application.UnLock();
- }
- (2) WebForm1.aspx
- private void Page_Load(object sender, System.EventArgs e)
- {
- this.Label1.Text = "正在访问站点的用户数:" + Application["CurrentGuests"].ToString();
- this.Label2.Text ="访问过站点的总用户数:" + Application["AllGuests"].ToString();
- }
- //存放信息
- Session["key"]="value"
- //读取数据
- string UserName=Session["key"].ToString();
- //存放信息
- Response.Cookies["key"].Value="value";
- //读取信息
- string UserID=Response.Cookies["key"].Value;
- //存放信息
- ViewState["key"]="value";
- //读取信息
- string NameID=ViewState["nameID"].ToString();
- //存放信息
- Cache["nameID"]="0001";
- //存放信息
- Cache.Insert("nameID","0001"1);
- //读取信息
- string NameID=Cache["nameID"].ToString();
- //存放信息
- Hidden.Value="0001";
- //获取信息
- string NameID=Hidden.Value;
- Response.Redirect("List.aspx?nameID=0001&gradeID=002");
- //执行上面的语句后在IE地址栏显示的URL的代码如下。
- http://localhost/List.aspx?nameID=0001&grade=002
- //当跳转到List.aspx后,可以通过以下代码获得所传递的信息。
- string NameID.GradeID;
简述: Ajax 的原理就是: 通过 javascript 的方式,将前台数据通过 xmlhttp 对象传递到后台,后台在接收到请求后,将需要的结果,再传回到前台,这样就可以实现不需要页面的回发,页是数据实现来回传递,从页实现无刷新。
总结:我们可以看出,XMLHttpRequest 对象完全用来向服务器发出一个请求的,它的作用也局限于此,但它的作用是整个 ajax 实现的关键,我们可以把服务器端看成一个数据接口,它返回的是一个纯文本流,当然,这个文本流可以是 XML 格式,可以是 Html,可以是 Javascript 代码,也可以只是一个字符串。这时候,XMLHttpRequest 向服务器端请求这个页面,服务器端将文本的结果写入页面,这和普通的 web 开发流程是一样的,不同的是,客户端在异步获取这个结果后,不是直接显示在页面,而是先由 javascript 来处理,然后再显示在页面。
属性 | 索引器 |
---|---|
通过名称标识 | 通过签名标识 |
通过简单名称或成员访问来访问 | 通过元素访问来访问 |
可以为静态成员或实例成员 | 必须为实例成员 |
属性的 get 访问器没有参数 | 索引器的 get 访问器具有与索引器相同的形参表 |
属性的 set 访问器包含隐式 value 参数器 | 除了 value 参数外,索引的 set 访问器还具有与索引器相同的形参表 |
String 类原理:String 类是一种传统的修改字符串的方式,它确实可以完成把一个字符串添加到另一个字符串上的工作没错, 但是在. NET 框架下,这个操作实在是划不来。因为系统先是把两个字符串写入内存,接着删除原来的 String 对象,然后创建一个 String 对象,并读取内存中的数据赋给该对象。这一来二去的,耗了不少时间。
StringBulider 原理:而使用 System.Text 命名空间下面的 StringBuilder 类就不是这样了,它提供的 Append 方法,能够在已有对象的原地进行字符串的修改,简单而且直接。
提醒:一般情况下觉察不到这二者效率的差异,但如果你要对某个字符串进行大量的添加操作,那么 StringBuilder 类所耗费的时间和 String 类简直不是一个数量级的
- 访问修辞符 enum 枚举名:基础类型
- {
- 枚举成员
- }
- public enum TimeofDay:uint
- {
- Morning=-3,
- Afternoon=-2,
- Evening=-1
- }
产生编译时错误,原因是常数值 -1、-2 和 –3 不在基础整型 uint 的范围内。
- 示例:
- public enum TimeofDay:uint
- {
- Morning,
- Afternoon,
- Evening
- }
Morning 的值为 0,Afternoon 的值为 1,Evening 的值为 2。
- public enum Number
- {
- a=1,
- b,
- c=1,
- d
- }
b 的值为 2,d 的值为 2.
注意:以上枚举值都不能超过它的基础类型范围。否则会报错.
- public enum Number
- {
- a,
- b,
- c,
- d
- }
- class Test
- {
- public static void Main()
- {
- int i=Number.a;//错误,要强制类型转换(int)Number.a
- Number n;
- n=2 //错误,要强制类型转换(Number)2
- }
- }
- using System;
- public enum TimeofDay
- {
- Morning,
- Afternoon,
- Evening
- }
- class Test
- {
- static void WriteGreeting(TimeofDay timeofDay)
- {
- switch(timeofDay)
- {
- case TimeofDay.Morning:
- Console.WriteLine("good morning");
- break;
- case TimeofDay.Afternoon:
- Console.WriteLine("good afternoon");
- break;
- case TimeofDay.Evening:
- Console.WriteLine("good evening");
- break;
- }
- }
- static void Main()
- {
- WriteGreeting(TimeofDay.Morning);
- WriteGreeting(TimeofDay.Evening);
- WriteGreeting(TimeofDay.Afternoon);
- }
- }
- 例:int myInt=new int();
myInt 初始化为 0,它是 int 类型的默认值。该语句的效果等同于:intmyInt=0;
请看下面的类:
- public class MyClass
- {
- public int x;
- public void Invoke(){}
- }
在派生类中用 Invoke 名称声明成员会隐藏基类中的 Invoke 方法,即:
- public class MyDerivedC:MyClass
- {
- new public void Invoke(){}
- }
但是,因为字段 x 不是通过类似名隐藏的,所以不会影响该字段。
通过继承隐藏名称采用下列形式之一:
1. 引入类或结构中的常数、指定、属性或类型隐藏具有相同名称的所有基类成员。
2. 引入类或结构中的方法隐藏基类中具有相同名称的属性、字段和类型。同时也隐藏具有相同签名的所有基类方法。
3. 引入类或结构中的索引器将隐藏具有相同名称的所有基类索引器。
4. 在同一成员上同时使用 new 和 override 是错误的。
注意:在不隐藏继承成员的声明中使用 new 修饰符将生成警告。
- using System;
- public class MyBaseC
- {
- public class MyClass
- {
- public int x=200;
- public int y;
- }
- }
- public class MyDerivedC:MyBaseC
- {
- new public class MyClass //nestedtypehidingthebasetypemembers
- {
- public int x=100;
- public int y;
- public int z;
- }
- public static void Main()
- {
- //Creating object from the overlapping class:
- MyClass S1=new MyClass();
- //Creating object from the hidden class:
- MyBaseC.MyClass S2=new MyBaseC.MyClass();
- Console.WriteLine(S1.x);
- Console.WriteLine(S2.x);
- }
输出:
100
200
来源: http://www.cnblogs.com/renyiqiu/p/6475719.html