C#基础概念

const和static readonly的区别

const:编译期初始化

static readonly: 运行期初始化

extern的用法

引进程序集外的函数

 注意DllImport是一个Attribute，在System.Runtime.InteropServices命名空间中定义

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

namespace ConsoleApplication4
{

    class Program
    {
        [DllImport("User32.dll")]
        public static extern int MessageBox(int Handle, string Message, string Caption, int Type);
        static int Main(string[] args)
        {
            string myString;
            Console.WriteLine("enter your message:");
            myString = Console.ReadLine();
            return MessageBox(0,myString,"mymessagebox",0);
        }
    }
}

abstract的用法

abstract 修饰符可以用于类、方法、属性、事件和索引指示器（indexer），表示其为抽象成员
abstract 不可以和 static 、virtual 、override 一起使用
声明为 abstract 成员可以不包括实现代码，但只有类中还有未实现的抽象成员，该类就不可以被实例化，通常用于强制继承类必须实现某一成员

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

namespace ConsoleApplication4
{
    public abstract class BaseClass
    {
        public abstract String Attribute
        {
            get;
            set;
        }
        public abstract void Function();
        public abstract event EventHandler Event;
        public abstract Char this[int index]
        {
            get;
        }
    }
    public class DeriveClass : BaseClass
    {
        private string attribute;
        public override string Attribute
        {
            get
            {
                return attribute;
            }
            set
            {
                attribute = value;
            }
        }
        public override void Function()
        {
            if (Event != null)
            {
                Event(this,new EventArgs());
            }
        }
        public override event EventHandler Event;
        public override char this[int index]
        {
            get 
            {
                return attribute[index];
            }
        }
    }
    class Program
    {
        static void OnFunction(object sender, EventArgs e)
        {
            for (int i = 0; i < ((DeriveClass)sender).Attribute.Length; i++)
            {
                Console.WriteLine(((DeriveClass)sender)[i]);
            }
        }
        static void Main(string[] args)
        {
            DeriveClass tmpobj = new DeriveClass();
            tmpobj.Attribute = "1234567";
            Console.WriteLine(tmpobj.Attribute);
            tmpobj.Event += OnFunction;
            tmpobj.Function();
        }
    }
}

 可以使用抽象函数重写基类中的虚函数吗？

    class BaseClass
    {
        public virtual void F()
        {
            Console.WriteLine("BaseClass.f");
        }
    }
    abstract class DeriveClass : BaseClass
    {
        public new abstract void F();
    }