C#知识点有必要知会


如果说你父类里面有一个成员比如int  a;那么你子类里面也可以再定义一个int a，这个时候base.a和this.a表示的就不是一个变量了，如果说子类里面没有，那么base.a和this.a表示的都是一个变量。还有就是重写，覆盖和构造函数里面调用父类的这个方法。可以用:base（），还有就是关于形参名和成员变量相同的时候，因为是就近原则，所以直接写变量名字表示的就是形参，如果加了this表示的就是这个类的成员。C#里面的this和base 跟JAVA里面的this和super是一样的。你在定义一个变量的时候有一个this引用，指向自身，还有一个引用base，指向父类。关于你说的那种情况就是我说的第一种，如果子类成员有和父类成员同名的时候，就必须用this和base区分。


http://www.cnblogs.com/annabook/p/4794958.html
this 用法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace dazilianxi
{
   public class testthis
    {
       
       public testthis(int capacity) : this(capacity, null) { }
       public testthis(int capacity, string fangfa) : this(capacity, fangfa, null) { }
       public testthis(int capacity, string fangfa, string canshu) : this(capacity, fangfa, canshu, null) { }
       public testthis(int capacity,string fangfa,string canshu,string tuxing){
           if (canshu == "yuan" && fangfa == "mianji")
           {
               Console.WriteLine("圆的面积是---------------｛0｝"+ capacity * capacity*3.14);
           }
           if (tuxing == "changfangxing") {
               Console.WriteLine("长方形的周长---------------｛0｝"+(capacity + int.Parse(fangfa) * 2));
           }
           if (tuxing == "sanjiaoxing") {
               Console.WriteLine("三角形最稳固,面积---------------｛0｝"+capacity*int.Parse(canshu)/2);
           }
           if (tuxing == null)
           {
               Console.WriteLine("未知图像图形");
           }
       }
    }
}

 testthis tb = new testthis(100);
            testthis tb2 = new testthis(5, "mianji", "yuan");
            testthis tb3 = new testthis(5, "10", null, "changfangxing");
            testthis tb4 = new testthis(6, null, "10", "sanjiaoxing");

输出结果：



base用法
在本例中，基类 Person 和派生类 Employee 都有一个名为 Getinfo 的方法。通过使用 base 关键字，可以从派生类中调用基类的 Getinfo 方法。
//强调调用方法 在｛｝里面

public class Person
{
    protected string ssn = "444-55-6666";
    protected string name = "John L. Malgraine";

    public virtual void GetInfo()
    {
        Console.WriteLine("Name: {0}", name);
        Console.WriteLine("SSN: {0}", ssn);
    }
}
class Employee : Person
{
    public string id = "ABC567EFG";
    public override void GetInfo()
    {
        // Calling the base class GetInfo method:
        base.GetInfo();
        Console.WriteLine("Employee ID: {0}", id);
    }
}

class TestClass
{
    static void Main()
    {
        Employee E = new Employee();
        E.GetInfo();
    }
}
/*
Output
Name: John L. Malgraine
SSN: 444-55-6666
Employee ID: ABC567EFG
*/

本示例显示如何指定在创建派生类实例时调用的基类构造函数。在｛｝外面

public class BaseClass
{
    int num;

    public BaseClass()
    {
        Console.WriteLine("in BaseClass()");
    }

    public BaseClass(int i)
    {
        num = i;
        Console.WriteLine("in BaseClass(int i)");
    }

    public int GetNum()
    {
        return num;
    }
}

public class DerivedClass : BaseClass
{
    // This constructor will call BaseClass.BaseClass()
    public DerivedClass() : base()
    {
    }

    // This constructor will call BaseClass.BaseClass(int i)
    public DerivedClass(int i) : base(i)
    {
    }

    static void Main()
    {
        DerivedClass md = new DerivedClass();
        DerivedClass md1 = new DerivedClass(1);
    }
}
/*
Output:
in BaseClass()
in BaseClass(int i)
*/

为system对象添加扩展方法

C#扩展方法：

编写扩展方法有下面几个要求：

第一：扩展方法所在的类必须是全局的，不能是内部嵌套类。

第二：扩展方法的类是静态类。

第三：扩展方法是静态方法。

第四：扩展方法的第一个参数的数据类型必须是要扩展类型。

第五：扩展方法的第一个参数使用this关键字。

参考一http://www.cnblogs.com/fang-beny/p/5267885.html

////扩展方法类:必须为非嵌套,非泛型的静态类
       public static class DatetimeEx
       {
           //通过this声明扩展的类，这里给DateTime类扩展一个Show方法，只有一个参数
           public static void Show(this DateTime date, string msg)
           {
               Console.WriteLine("扩展方法调用");
               Console.WriteLine(msg);
           }
       }

参考二http://www.cnblogs.com/hshuai/p/3594238.html

参考三http://www.cnblogs.com/namek/archive/2010/08/17/1801275.html

using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;

 namespace ExtensionMethod
{
    public static class TestClass
    {
        public static void Print(this int i)
        {
            Console.WriteLine(i);
        }

        public static int Times(this int i)
        {
            return i * 2;
        }

        public static int Add(this int i, int d)
        {
            return i + d;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            int number = 4;
            number.Print();
            Console.WriteLine(number.Times());
            Console.WriteLine(number.Add(5));
        }
    }
}

代码很简单，扩展的是int类型。

第一个是定义了一个Print方法，是没有参数没有返回值的扩展方法。

第二个是定义了一个带返回值无参数的扩展方法。

第三个是定义了一个有返回值有参数的扩展方法。

参考四 http://www.cnblogs.com/hachun/p/4549078.html

扩展方法

　　扩展方法，它允许定义一个静态方法，并用实例方法的语法来调用它。定义的时候，第一个参数是和当前用于调用方法的那个表达式（下例中的sb（StringBuilder））的类型匹配的一个类型，且须在参数前添加 this 关键字。先看个例子：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ExtensionMethod
{
    // 在此类中定义扩展方法
    public static class StringBuilderExtensions
    {
        public static Int32 IndexOf(this StringBuilder sb, Char Value)
        {
            for (Int32 index = 0; index < sb.Length; index++)
            {
                if (sb[index] == Value)
                    return index;
            }

            return -1;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            StringBuilder sb = new StringBuilder("Hachun");
            
            // sb对象直接调用扩展方法 IndexOf
            Int32 pos = sb.IndexOf('c');
            Console.WriteLine(pos);
            Console.ReadKey();
        }
    }
}

扩展方法的一些原则：

1.c#只支持扩展方法，不支持扩展属性，扩展事件等，但可以为接口类型定义扩展方法，任何实现该接口的类，都可以调用此扩展方法；

2.扩展方法必须在非泛型的静态类中声明，类名没有限制，可以随意叫。当然，扩展方法至少要有一个参数，且须用 this 标记；

3.c#编译器查找静态类中定义的扩展方法时，要求这些静态类本身必须具有文件作用域（类要有整个文件的作用域，而不能嵌套到一个类中，只具有该类的作用域）。换言之，如果静态类嵌套在另一个类中，c#编译器会报错；

4.用一个扩展方法扩展一个类时，相应的派生类也会被扩展，所以，慎用；

C#中Abstract和Virtual

在C#的学习中，容易混淆virtual方法和abstract方法的使用，现在来讨论一下二者的区别。二者都牵涉到在派生类中与override的配合使用。

一、Virtual方法（虚方法）

     virtual 关键字用于在基类中修饰方法。virtual的使用会有两种情况：

     情况1：在基类中定义了virtual方法，但在派生类中没有重写该虚方法。那么在对派生类实例的调用中，该虚方法使用的是基类定义的方法。

     情况2：在基类中定义了virtual方法，然后在派生类中使用override重写该方法。那么在对派生类实例的调用中，该虚方法使用的是派生重写的方法。

二、Abstract方法（抽象方法）

     abstract关键字只能用在抽象类中修饰方法，并且没有具体的实现。抽象方法的实现必须在派生类中使用override关键字来实现。

接口和抽象类:

最本质的区别：抽象类是一个不完全的类，是对对象的抽象，而接口是一种行为规范。

C# 是面向对象的程序设计语言，每一个函数都属于一个类。
Static：当一个方法被声明为Static时，这个方法是一个静态方法，编译器会在编译时保留这个方法的实现。也就是说，这个方法属于类，但是不属于任何成员，不管这个类的实例是否存在，它们都会存在。就像入口函数Static void Main，因为它是静态函数，所以可以直接被调用。

Virtua：当一个方法被声明为Virtual时，它是一个虚拟方法，直到你使用ClassName variable = new ClassName();声明一个类的实例之前，它都不存在于真实的内存空间中。这个关键字在类的继承中非常常用，用来提供类方法的多态性支持。
overrride：表示重写这个类是继承于Shape类
public override double Area 这个属性再shape中肯定存在但是这里我们不想用shape中的所以要重写
virtual，abstract是告诉其它想继承于他的类你可以重写我的这个方法或属性，否则不允许。
一个生动的例子 :老爸表示基类（被继承的类）儿子表示子类（继承的类）
老爸用virtual告诉儿子:"孩子,你要继承我的事业,在这块上面可以自己继续发展你自己的"
儿子用override告诉全世界:"这个我可不是直接拿我爸的,他只是指个路给我,是我自己奋斗出来的"

abstract：抽象方法声明使用，是必须被派生类覆写的方法，抽象类就是用来被继承的；可以看成是没有实现体的虚方法；如果类中包含抽象方法，那么类就必须定义为抽象类，不论是否还包含其他一般方法；抽象类不能有实体的。
实例解答:
interface:用来声明接口
1.只提供一些方法规约，不提供方法主体. 如:
public interface IPerson
{
void getName();//不包含方法主体
}
2.方法不能用public abstract等修饰,无字段变量，无构造函数。
3.方法可包含参数。如
public interface IPerson
{
void getAge(string s);
}
一个例子(例1)：
public interface IPerson
{
IPerson(); //错误
string name; //错误
public void getIDcard();//错误
void getName(); //right
void getAge(string s); //right
}
实现interface的类
1.与继承类的格式一致，如 public class Chinese:IPerson{}
2.必须实现 interface 中的各个方法
例2，继承例1
public class Chinese:IPerson
{
public Chinese(){} //添加构造
public void getName(){} //实现getName()
public void getAge(string s){} //实现getAge()
}
abstract:声明抽象类、抽象方法
1.抽象方法所在类必须为抽象类
2.抽象类不能直接实例化，必须由其派生类实现。
3.抽象方法不包含方法主体，必须由派生类以override方式实现此方法,这点跟interface中的方法类似
如
public abstract class Book
{
public Book()
{
}
public abstract void getPrice(); //抽象方法，不含主体
public virtual void getName() //虚方法，可覆盖
{
Console.WriteLine("this is a test:virtual getName()");
}
public virtual void getContent() //虚方法，可覆盖
{
Console.WriteLine("this is a test:virtual getContent()");
}
public void getDate() //一般方法，若在派生类中重写，须使用new关键字
{
Console.WriteLine("this is a test: void getDate()");
}
}
public class JavaBook:Book
{
public override void getPrice() //实现抽象方法，必须实现
{
Console.WriteLine("this is a test:JavaBook override abstract getPrice()");
}
public override void getName() //覆盖原方法，不是必须的
{
Console.WriteLine("this is a test:JavaBook override virtual getName()");
}
}
测试如下：
public class test
{
public test()
{
JavaBook jbook=new JavaBook();
jbook.getPrice(); //将调用JavaBook中getPrice()
jbook.getName(); //将调用JavaBook中getName()
jbook.getContent(); //将调用Book中getContent()
jbook.getDate(); //将调用Book中getDate()
}
public static void Main()
{
test t=new test();
}
}
virtual:标记方法为虚方法
1.可在派生类中以override覆盖此方法
2.不覆盖也可由对象调用
3.无此标记的方法(也无其他标记)，重写时需用new隐藏原方法
abstract 与virtual : 方法重写时都使用 override 关键字
接口定义以大写字母I开头。方法只定义其名称,在C#中，方法默认是公有方法；用public修饰方法是不允许的,否则会出现编译错误；接口可以从别的接口继承，如果是继承多个接口，则父接口列表用逗号间隔。
接口可以通过类来实现，当类的基列表同时包含基类和接口时，列表中首先出现的是基类；类必须要实现其抽象方法；
接口使用：见代码（转）
interface使用
interface使用（实例一）
using System;
namespace Dage.Interface
{
//打印机接口
public interface IPrint
{
string returnPrintName();
}
}
//--------------------------------------------
using System;
using Dage.Interface;
namespace Dage.Print
{
//HP牌打印机类
public class HP: IPrint
{
public string returnPrintName()
{
return "这是HP牌打印机";
}
}
}
//--------------------------------------------
using System;
namespace Dage.Print
{
//Eps牌打印机类
public class Eps: IPrint
{
public string returnPrintName()
{
return "这是Eps牌打印机";
}
}
}
//--------------------------------------------
using System;
using Dage.Interface;
namespace Dage
{
//打印类
public class Printer
{
public Printer()
{}
public string PrintName(IPrint iPrint)
{
return iPrint.returnPrintName();
}
}
}
//--------------------------------------------
--WinFrom中调用代码:
private void button1_Click(object sender, System.EventArgs e)
{
Printer p= new Printer();
switch (this.comboBox1.Text)
{
case "HP":
MessageBox.Show(p.PrintName(new HP()));
break;
case "Eps":
MessageBox.Show(p.PrintName(new Eps()));
break;
default:
MessageBox.Show("没有发现这个品牌！");
break;
}
}