C#的25个基础概念（抄）-优快云博客

1.静态变量和非静态变量的区别？
答：
静态变量
静态变量使用static修饰符进行声明，在所属累被装载时创建，通过类进行访问。所属类的所有实例的同一静态变量都是同一个值。
非静态变量
不带有static修饰符声明的变量称作非静态变量，在类被实例化时创建。
通过对象进行访问。同一个类的不同实例的同一非静态变量可以是不同的值。

Code

using System;

using System.Collections.Generic;

using System.Text;

namespace Example01

{

class program

{

class Class1

{

public static String staticStr ="class";

public String notstaticStr ="obj";

}

static void Main(string[] args)

{

//静态变量通过类进行访问，该类所有的实例的同一静态变量都时同一个值。

Console.WriteLine(

{0},Class1.staticStr);

Class1 tmpObj1 = new Class1();

tmpObj1.notstaticStr = "tmpObj1";

Class 2 tmpObj2 = new Class();

//非静态变量通过对象进行访问，不同的对象的同一非静态变量可以有不同的值。

}

结果：
Class1 ' s staticStr: Class
tmpObj1 ' s notstaticStr: tmpObj1
tmpObj2 ' s notstaticStr: tmpObj2

2.const 和static readonly 区别？
答：
const
用const修饰符声明的变量叫常量，是在编译期初始化嵌入到客户端程序static readonly
用static readonly 修饰符声明的成员依然是变量，只不过具有和常量类似的使用方法，通过类进行访问，初始化后不可以修改。但与常量不同的时这种变量时在运行期初始化

测试类：
using System;
using System.Collections.Generic;
using System.Text;
namespace Example02Lib
{
    public class Class1
    {
        public const String strConst = &quot;Const&quot;;
        public static readonly String strStaticReadonly = &quot;StaticReadonly&quot;;
        //public const String strConst = &quot;Const Changed&quot;;
        //public static readonly String strStaticReadonly = &quot;StaticReadonly Changed&quot;;
    }//5-1-a-s-p-x
}

客户端代码：
using System;
using System.Collections.Generic;
using System.Text;
using Example02Lib;
namespace Example02
{
    class Program
    {
        static void Main(string[] args)
        {
            //修改Example02中Class1的strConst初始值后，只编译Example02Lib项目
            //然后到资源管理器里把新编译的Example02Lib.dll拷贝Example02.exe所在的目录，执行Example02.exe
            //切不可在IDE里直接调试运行因为这会重新编译整个解决方案！！
            //可以看到strConst的输出没有改变，而strStaticReadonly的输出已经改变
            //表明Const变量是在编译期初始化并嵌入到客户端程序，而StaticReadonly是在运行时初始化的
            Console.WriteLine(&quot;strConst : {0}&quot;, Class1.strConst);
            Console.WriteLine(&quot;strStaticReadonly : {0}&quot;, Class1.strStaticReadonly);
            Console.ReadLine();
        }
    }
}

3.extern 是什么意思？
答：
extern 修饰符用于声明由程序及外部实现的成员函数，经常用与系统API函数的调用（通过 DLLImport）.注意，和DllImport一起使用时要加上static修饰符，也可以用于对于同一程序集不同版本的组件的调用（用extern声明别名）不能与abstract修饰符同时使用；

Code
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
namespace Example03
{
    class Program
    {
        //注意DllImport是一个Attribute Property，在System.Runtime.InteropServices命名空间中定义
        //extern与DllImport一起使用时必须再加上一个static修饰符
        [DllImport(&quot;User32.dll&quot;)]
        public static extern int MessageBox(int Handle, string Message, string Caption, int Type);
        static int Main()
        {
            string myString;
            Console.Write(&quot;Enter your message: &quot;);
            myString = Console.ReadLine();
            return MessageBox(0, myString, &quot;My Message Box&quot;, 0);
        }
    }
}

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

Code
using System;
using System.Collections.Generic;
using System.Text;
namespace Example04
{
    #region 基类，抽象类
    public abstract class BaseClass
    {
        //抽象属性，同时具有get和set访问器表示继承类必须将该属性实现为可读写
        public abstract String Attribute
        {
            get;
            set;
        }
        //抽象方法，传入一个字符串参数无返回值
        public abstract void Function(String value);
        //抽象事件，类型为系统预定义的代理(delegate)：EventHandler
        public abstract event EventHandler Event;
        //抽象索引指示器，只具有get访问器表示继承类必须将该索引指示器实现为只读
        public abstract Char this[int Index]
        {
            get;
        }
    }
    #endregion
    #region 继承类
    public class DeriveClass : BaseClass
    {
        private String attribute;
        public override String Attribute
        {
            get
            {
                return attribute;
            }
            set
            {
                attribute = value;
            }
        }
        public override void Function(String value)
        {
            attribute = value;
            if (Event != null)
            {
                Event(this, new EventArgs());
            }
        }
        public override event EventHandler Event;
        public override Char this[int Index]
        {
            get
            {
                return attribute[Index];
            }
        }
    }
    #endregion
    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 = &quot;1234567&quot;;
            Console.WriteLine(tmpObj.Attribute);
            //将静态函数OnFunction与tmpObj对象的Event事件进行关联
            tmpObj.Event += new EventHandler(OnFunction);
            tmpObj.Function(&quot;7654321&quot;);
            Console.ReadLine();
        }
    }
}

结果：
1234567
7
6
5
4
3
2
1

转载于:https://www.cnblogs.com/mygood/articles/1407028.html