C#学习笔记
抽象类
格式 abstract class class_name
注意
抽象类只可以作为其它类的基类，不可以直接被实例化，不可使用new操作符，抽象类如果含有抽象的变量或值，要么是null类型，要么包含了对非抽象类的实例引用。抽象类允许包含抽象成员，不可以同时又是密封的。
抽象类的派生类，如果没有包含对抽象类方法的实现，那么派生类也必须是抽象类。如果派生类对抽象类方法进行重载，并提供方法的具体实现，则该类可以是非抽象类。
例
abstract class a
{
public abstract void f();
}
abstract class b:a/ //必须是抽象类
{
public void g();
}
abstract class c:b //可以不是抽象类
{
public override void f()
{
Console.Write(“a”);
}
}抽象方法
试例 public abstract void mothed_name()；
注意
抽象方法只能在抽象类中声明，默认是虚方法（可用override重载），不提供具体实现代码，它的执行体中只有一个分号“；”（在圆号后面）不可以带主体，那怕只是{}也不行，
抽象方法重载的虚方法时，基类中虚方法的执行代码将被“拦截”如下例
class a
{
public virtual void f()
{
Console.WriteLine(“a.f”);
}
}
abstract class b:a
{
public abstract override void f();
}
class c:b
{
public override void f()
{
Console.WriteLine(“c.f”);
}
}密封类
用scaled修饰符声明，不可以被继承，不可以是抽象类，在密封类实例中修饰符virtual无效
密封方法
密封方法必须对虚方法进行重载，所以sealed修饰符总是和override修饰符同时使用
属性的继承
规则 属性重载时，如果基类只有一个属性访问器，那么返璞归重载后的属性也只可以有一个，如果基类同时包含了get和set属性访问器，那么重载的属性可以只有一个，也可以同时有两个。
属性重载声明中，属性的名称，类型，访问修饰符都应该与被继承的属性一致。
注意：与方法重载不同的是，属性的重载声明实际上并没有声明新闻属性，而只是为已有的虚属性提供访问器的具体实现。
虚属性的访问器，包括get访问器与set访问器，同样也是虚的。
抽象属性的访问器也是虚的，而且不提供访问器的具体实现，必须在派生类中通过重载来提供对访问器的具体实现，抽象属性只可以在抽象类中申明
密封属性声明时必须与override修饰符同时使用，不可以在派生类中被继承。接口（interface）含义：接口描述了组件对上提供的服务，在组件和组件之间，、组件和客户之间都通过接口进行交互。组件一旦发布只能通过预先定义的接口来提供合理的，一致性的服务。一个组件可以实现多个组件接口，而一个特定的组件接口也可以被多个组件来实现。接口是组件之间的协议，组件只可以通过接口与外部通信，目前组件封闭标准是IDL语言。
接口定义试例：
interface Icontrol
{
voiid Pain();
}接口的继承
接口继承和类继承不同，首先，类继承不仅是说明继承，面且也是实现继承，而接口继承只说明继承，也就是说派生类可以继承基类的方法实现，而派生接口只继承父接口的成员方法说明，面没有继承父接口的实现，类继承只允许单继承，但接口可以多继承，一个子接口可以有多个父接口。从多个接口继承用“：”后跟被继承的接口名字，多接口之间用“，”隔开，被继承的接口应该是可以访问得到的，private类型或internal类型的接口继承是不允许的，接口不允许直接或间接从本身继承。
注意：接口不可以包含静态成员，接口成员可以是方法，属性，索引指示器和事件，不可以是常量，域，操作符，构造函数莴苣析构函数。并且接口成员申请不可以包含任何修饰符，他本身默认是public的，成员之间不可以同名，但可以定义与继承来的成员同名的成员（在声明成员前为个new关键字），
对接口访问时，由于接口可以多继承，如果在多继承中有两个父接口有同名成员，这就发生二义性，这是需要进行显示的声明（（父接口名）操作数）.成员名=值
接口的全权名定义是这样的：接口名加小圆点“。”再跟成员名
抽象类
格式 abstract class class_name
注意
抽象类只可以作为其它类的基类，不可以直接被实例化，不可使用new操作符，抽象类如果含有抽象的变量或值，要么是null类型，要么包含了对非抽象类的实例引用。抽象类允许包含抽象成员，不可以同时又是密封的。
抽象类的派生类，如果没有包含对抽象类方法的实现，那么派生类也必须是抽象类。如果派生类对抽象类方法进行重载，并提供方法的具体实现，则该类可以是非抽象类。
例
abstract class a
{
public abstract void f();
}
abstract class b:a/ //必须是抽象类
{
public void g();
}
abstract class c:b //可以不是抽象类
{
public override void f()
{
Console.Write(“a”);
}
}抽象方法
试例 public abstract void mothed_name()；
注意
抽象方法只能在抽象类中声明，默认是虚方法（可用override重载），不提供具体实现代码，它的执行体中只有一个分号“；”（在圆号后面）不可以带主体，那怕只是{}也不行，
抽象方法重载的虚方法时，基类中虚方法的执行代码将被“拦截”如下例
class a
{
public virtual void f()
{
Console.WriteLine(“a.f”);
}
}
abstract class b:a
{
public abstract override void f();
}
class c:b
{
public override void f()
{
Console.WriteLine(“c.f”);
}
}密封类
用scaled修饰符声明，不可以被继承，不可以是抽象类，在密封类实例中修饰符virtual无效
密封方法
密封方法必须对虚方法进行重载，所以sealed修饰符总是和override修饰符同时使用
属性的继承
规则 属性重载时，如果基类只有一个属性访问器，那么返璞归重载后的属性也只可以有一个，如果基类同时包含了get和set属性访问器，那么重载的属性可以只有一个，也可以同时有两个。
属性重载声明中，属性的名称，类型，访问修饰符都应该与被继承的属性一致。
注意：与方法重载不同的是，属性的重载声明实际上并没有声明新闻属性，而只是为已有的虚属性提供访问器的具体实现。
虚属性的访问器，包括get访问器与set访问器，同样也是虚的。
抽象属性的访问器也是虚的，而且不提供访问器的具体实现，必须在派生类中通过重载来提供对访问器的具体实现，抽象属性只可以在抽象类中申明
密封属性声明时必须与override修饰符同时使用，不可以在派生类中被继承。接口（interface）含义：接口描述了组件对上提供的服务，在组件和组件之间，、组件和客户之间都通过接口进行交互。组件一旦发布只能通过预先定义的接口来提供合理的，一致性的服务。一个组件可以实现多个组件接口，而一个特定的组件接口也可以被多个组件来实现。接口是组件之间的协议，组件只可以通过接口与外部通信，目前组件封闭标准是IDL语言。
接口定义试例：
interface Icontrol
{
voiid Pain();
}接口的继承
接口继承和类继承不同，首先，类继承不仅是说明继承，面且也是实现继承，而接口继承只说明继承，也就是说派生类可以继承基类的方法实现，而派生接口只继承父接口的成员方法说明，面没有继承父接口的实现，类继承只允许单继承，但接口可以多继承，一个子接口可以有多个父接口。从多个接口继承用“：”后跟被继承的接口名字，多接口之间用“，”隔开，被继承的接口应该是可以访问得到的，private类型或internal类型的接口继承是不允许的，接口不允许直接或间接从本身继承。
注意：接口不可以包含静态成员，接口成员可以是方法，属性，索引指示器和事件，不可以是常量，域，操作符，构造函数莴苣析构函数。并且接口成员申请不可以包含任何修饰符，他本身默认是public的，成员之间不可以同名，但可以定义与继承来的成员同名的成员（在声明成员前为个new关键字），
对接口访问时，由于接口可以多继承，如果在多继承中有两个父接口有同名成员，这就发生二义性，这是需要进行显示的声明（（父接口名）操作数）.成员名=值
接口的全权名定义是这样的：接口名加小圆点“。”再跟成员名
获得当前桌面分辨率
System.Windows.Forms.SystemInformation.WorkingArea.Width//当前分辨率宽
System.Windows.Forms.SystemInformation.WorkingArea.Height//当前分辨率高
自己窗口的宽与高
this.Size.Width//自己的宽
this.Size.Height//自己的高
this.ClientRectangle.Width;//工作区域的莺
this.ClientRectangle.Height;//工作区域的高
设置窗口寝位置
this.StartPosition = FormStartPosition.Manual;//窗口位置由Location属性决定
this.StartPosition = FormStartPosition.CenterParent;//在当前容器中居中
this.StartPosition = FormStartPosition.CenterScreen;//在当前窗口中居中
this.StartPosition = FormStartPosition.WindowsDefaultLocation;//定位在Windows默认位置，尺寸在窗口大小中决定
this.StartPosition = FormStartPosition.WindowsDefaultBounds;//定位在Windows默认位置，边界也由Windows默认决定this.Location = (Point)new Size(0, 0); //窗口的起始位置为0,0this.ClientSize = new System.Drawing.Size(x1,y1);//X1为宽度Y1为高度在MDI窗口中打开子窗口
Form1 mForm2=new Form1;
mForm2.MdiParent=this;(Form2是子窗口名）
mForm2.show();
在容器中打开子窗口
Form1 mForm2=new Form1;
this.panel1.Controls.Add(mForm2);(panel1是容器名,mForm2是子窗口名）
mForm2.show();日期型数据的赋值
DateTime dd=new DateTime(年，月，日，时，分,秒);
DateTime dd1=Convert.ToDateTime("yy/mm/dd/hh/mm/ss");
class a
{
Console.Write("test");
}
是不是这样的啊
你可以选择中代码，然后点这上面有个叫插入代码的按钮，选你要的语言就可以了
接口继承和类继承不同，首先，类继承不仅是说明继承，面且也是实现继承，而接口继承只说明继承，不对成员进行实现，也就是说派生类可以继承基类的方法实现，而派生接口只继承父接口的成员方法说明，面没有继承父接口的实现，类继承只允许单继承，但接口可以多继承，一个子接口可以有多个父接口。从多个接口继承用“：”后跟被继承的接口名字，多接口之间用“，”隔开，被继承的接口应该是可以访问得到的，private类型或internal类型的接口继承是不允许的，接口不允许直接或间接从本身继承。
注意：接口不可以包含静态成员，接口成员可以是方法，属性，索引指示器和事件，不可以是常量，域，操作符，构造函数莴苣析构函数。并且接口成员申请不可以包含任何修饰符，他本身默认是public的，成员之间不可以同名，但可以定义与继承来的成员同名的成员（在声明成员前加个new关键字），
对接口访问时，由于接口可以多继承，如果在多继承中有两个父接口有同名成员，这就发生二义性，这是需要进行显示的声明(（（父接口名）操作数）).成员名
接口的全权名定义是这样的：接口名加小圆点“。”再跟成员名
using System;
interface a
{
void f();
}
interface b
{
void f();
}
interface c : a, b//多个接口可以同时被一个接口继承，一个类也可同时继承多个接口（这时可以同时继承一个类,类名放第一个），但一个类不可以同时继承多个类 {
string g
{
set;
get;
}
}
class e:c
{
void b.f()
{
Console.WriteLine("test b");
}
void a.f()
{
Console.WriteLine("test a");
}
string d;
string c.g//属性成员
{
set {d=value;}
get { return d; } }
static void Main()
{
c ee = new e();
((a)ee).f();//避免二义性，显式调用，
//ee.f()有二义性，是错误的写法
((b)ee).f();//避免二义性，显式调用
ee.g = "test c";
Console.WriteLine(ee.g);
Console.Read();
}
}
在接口调用时，如果每个成员都明显的指出了被实现的接口，我们称通过这种途径被实现的接口成员叫显式接口成员。例如上例中的
void b.f()//显式接口成员
{
Console.WriteLine("test b");
}
void a.f()//显式接口成员
{
Console.WriteLine("test a");
}显式接口成员只可以通过接口调用
隐式接口成员可以通过方法和接口调用，如下例
interface one
{
void pain();
void pain1();
}
class two : one
{
void one.pain()//显式接口成员 显式接口的定义不可以加public,private等修饰符
{
Console.WriteLine("显式调用");
}
public void pain1()//隐式接口成员
{
Console.WriteLine("隐式调用");
}}
class three
{
static void write()
{
two suan = new two();
//suan.pain();显式不可以通过方法调用
suan.pain1();//隐式可以通过方法调用
one ones = suan;
ones.pain();//显式只可以通过接口调用
ones.pain1();//隐式也可以通过接口调用
}
}
接口成员声明中的全权名，必须对应在接口中声明的成员
interface one
{
void pain();
}
interface two : one
{
void settext(string text);
}
class thr:two
{
void one.pain() { Console.WriteLine("test"); }
//void two.pain() { Console.WriteLine("test"); } pain()方法不是在接口two中声明的
void two.settext(string text)
{
Console.WriteLine("test");
}
}
类必须为在基类表中列出的所有接口的成员提供具体的实现，在类中定位接口成员的实现称之为接口映射
类对接口的继承必须对基类所有的接口成员进行实现。
interface one
{
void pain();
}
interface two : one
{
void settext(string text);
}
class thr:two
{
void two.settext(string text)
{
Console.WriteLine("test");
}
}
上面这个例子会报错，没有对接口two的settext成员方法进行实现多个继承接口继承同一个父接口，这个父接口的成员只可以在一个类中被实现一次。
interface one
{
void pain();
}
interface two : one
{
void settext(string text);
}
interface twos : one
{
void settext(string text1);
}
class thr:two
{
void one.pain() { Console.WriteLine("test"); }
void one.pain() { Console.WriteLine("test"); }//错误，已经实现过
void two.settext(string text)
{
Console.WriteLine("test");
}
void twos.settext(string text1)
{
Console.WriteLine("test");
}
}接口重实现：继承了接口实现的类可以对接口进行重实现，这个接口要求是在类声明的列表中出现过的，
interface one
{
void pain();
}
class on : one
{
void one.pain() {Console.WriteLine("on test"); }//进行接口成员方法实现
}
class tw : on, one
{
public void pain() { Console.WriteLine("two test"); }//进行接口成员方法重实现}
类在重实现一个接口时，同时重实现了该接口的所有父接口
名字空间，名词空间的声明是用关键字”namespace”后跟名字空间名和名字空间主体，然后再跟一个分号
名字单间的申声明要在编译单元的（源泉文件）第一行出现，要么作为成员出现在其它名字单间的声明中。在名字空间内部再声明的名字空间不可以与全局名字空间同名。名字空间隐式的使用public修饰符。在声明时不可以出现任何修饰符。
名字空间可以嵌套使用
namespace names
{
namespace xing
{
}
}
上面的代码等价于
namespace names.xing
{}
别名使用指示符
using System;
namespace names
{
namespace xing
{
class test
{
public int aaa;
public void f()
{
Console.WriteLine("test");
}
}
}
}
namespace shen
{
using shen = names.xing.test;//别名使用指示符
class b : shen
{
static void Main()
{
b bb = new b();
bb.f();
Console.Read();
}
}
}
名字空间使用指示符
using System;
namespace names
{
namespace xing
{
class test
{
public int aaa;
public void f()
{
Console.WriteLine("test");
}
}
}
}
namespace shen
{
using names.xing; //名字空间使用指示符
class b : test
{
static void Main()
{
b bb = new b();
bb.f();
Console.Read();
}
}
}
名字空间不会引用他嵌套内的类型
namespace N1.N2
{
class A
{
}
}
namespace N3
{
using N1;
class B : N2.A//这是错误的，没有引入类N2中的类A
{
}
}
将上面的代码改为
namespace N1.N2
{
class A
{
}
}
namespace N3
{
using N1.N2;
class B : A//这是正确的，
{
}
}
编译单元或名字空间主体中定义的成员将覆盖名字空间使用指示符导入的与他同名的成员
namespace N1.N2
{
class A
{ }
}
namespace N3
{
using N1.N2;
class A//引入的类A将会被覆盖
{ }
}如果引入了多个名字空间，在这些引入的名字空间中存在同名的成员，将出现二义性，这时需要使用别名指示符来区分。
namespace N1
{
class A
{ }
}
namespace N2
{
class A
{ }
}
namespace N3
{
using N1;
using N2;
using aa=N1.A;//声明别名指示
class b : A { }//产生二义性
class c : aa { }//正确，使用了别名指示
}
文件操作使用的名字空间是System.IO，它为我们提供了一个抽象的类Stream类
在文件操作时请注意目录的斜杠“\”，要用转意字符，或在前面加“@”符号
using System;
using System.IO;
class Test
{
public static void Main()
{
string path1, path2;
path1 = @"c:\mm";
path2 = "c:\\mm1";
Directory.CreateDirectory(path1);
Directory.CreateDirectory(path2);
}
}
目录的删除
Directory.Delete(@"c:\testdir");//删除空目录
Directory.Delete(@"c:\testdir",true);//同时删除目录下的内容
查看目录是否存在
Directory.Exists(@"c:\mm");//返回true表示存在，反之表示不存在
文本文件的写入
using System;
using System.IO;
class files
{
public static void Main()
{
string files = @"c:\mm\myfile.txt";
using (StreamWriter sw = new StreamWriter(files))
{
sw.WriteLine("file header");
sw.WriteLine("begin test the file write!");
sw.WriteLine("end file write");
}
}
}
或
using (StreamWriter ss=File.CreateText(files))
{
ss.WriteLine("input again");
ss.WriteLine("write end");
}
文本文件的读取
using (StreamReader sr = new StreamReader("c:\\mm\\myfile.txt"))
{
String line;
//读取c:\mm\myfile.txt文件，并显示出来
while ((line = sr.ReadLine()) != null)
{
Console.WriteLine(line);
}
}
或
StreamReader sr；
sr = File.OpenText("c:\\mm\\myfile.txt");
while (sr.Peek() != -1)//判断是否到最后一个字符之后
{
string str = sr.ReadLine();
Console.WriteLine(str);
}
在文本文件中追加数据
File.AppendAllText("c:\\fi.txt", "this is test words" + Environment.NewLine, Encoding.UTF8);//文件不存在将创建文件
或
using (StreamWriter ss = File.AppendText("c:\\f2.txt"))
{
ss.WriteLine("this is test words");//文件不存在将创建文件，只支持UTF-8码
}
Console.Read();
文件的复制，移动，删除
using System;
using System.IO;
class files{
static void Main()
{
File.Copy(@"c:\mm\myfile.txt", "c:\\myfile1.txt");//复制文件
File.Move(@"c:\\myfile1.txt","c:\\mm\\myfile1.txt");//移动文件
File.Delete(@"c:\mm\myfile1.txt");//删除文件
Console.Read();
}
}
小提示，在我们用Console.Write(“text,{0,-5}—{1,5}”,a,b)输出时，有{0，-5}与{1，5}，这里大括号中前面的一个数字是表示后面的元素索引，后面那个“-5”和“5”表示的是这个元素所占有的字符位，其中“-”负表示从左边算起，正表示从右边算起获得目录的子目录与文件信息
using System;
using System.IO;public class FileLength
{
public static void Main()
{
//定义一个目录.
DirectoryInfo di = new DirectoryInfo("d:\\");
// 获得目录的相关信息.
FileInfo[] fiArr = di.GetFiles();//获得文件信息
DirectoryInfo[] ds = di.GetDirectories();//获得目录信息
//显示目录下的文件大小
Console.WriteLine("The directory {0} contains the following files:", di.Name);
using (StreamWriter sw = new StreamWriter("c:\\mm\\file.txt"))
{
foreach (FileInfo f in fiArr)
sw.WriteLine("The size of {0} is {1} bytes.", f.Name, f.Length);
foreach (DirectoryInfo f1 in ds)
{
sw.WriteLine("目录 {0} 最后修改时间是 {1} ", f1.Name, f1.LastWriteTimeUtc);
Console.WriteLine("目录 {0,-25} 最后修改时间是 {1,25} ", f1.Name, f1.LastWriteTimeUtc);
} }
Console.Read();
}
}
查看指定目录的大小
using System;
using System.IO;
public class ShowDirSize
{
public static long DirSize(DirectoryInfo d)
{
long Size = 0;
// 文件大小相加.
FileInfo[] fis = d.GetFiles();
foreach (FileInfo fi in fis)
{
Size += fi.Length;
}
// 子目录大小相加.
DirectoryInfo[] dis = d.GetDirectories();
foreach (DirectoryInfo di in dis)
{
Size += DirSize(di);
}
return (Size);
}
public static void Main()
{
DirectoryInfo d1 = new DirectoryInfo("e:\\安装文件");
Console.WriteLine("文件夹 {0} 的总大小是 {1} 字节.", d1, DirSize(d1));
Console.Read(); }
}
判断文件是否存在
File.Exists(“c:\\my.txt”)
二进制文件的读取与写入
//数据的写入
FileStream fs = new FileStream(FILE_NAME, FileMode.CreateNew);
BinaryWriter w = new BinaryWriter(fs)
w.Write(1234);
//数据的读取
fs = new FileStream(FILE_NAME, FileMode.Open, FileAccess.Read);
BinaryReader r = new BinaryReader(fs);while(r.PeekChar()!=-1)
{
Console.WriteLine(r.ReadInt32());
}