C#面试题基础

1.什么是GAC，他的作用是什么？

我的这篇文章有详细的介绍

https://www.cnblogs.com/zxtang/p/14313273.html

2.描述一个被protected interal 修饰的类成员的访问权限？

public 关键字是方法和成员的访问修饰符。公共访问public是允许的最高访问级别，对访问公共成员没有限制。protected 关键字是一个成员访问修饰符。受保护成员在它的类中可访问并且可由派生类访问。private 关键字是一个成员访问修饰符。私有访问是允许的最低访问级别。私有成员只有在声明它们的类和结构体中才是可访问的。internal 关键字是类型和类型成员的访问修饰符。只有在同一程序集的文件中，内部类型或成员才是可访问的。

3.const和readOnly的区别？

const表示不变常量，也就是不能被修改，readonly表示只读的，也就是不能进行写的操作。readOnly和const都用来标识常量，常量成员是在编译时定义的，不能在运行时更改。两者的区别在于：

（1）.使用const关键字将const声明为字段，并且必须在声明const对其进行初始化（也就是必须声明的同时必须赋值），而readonly可以声明为只读字段时进行初始化，也可以只声明而在构造函数中进行初始化，且readonly只能初始化一次,构造后，只读字段无法更改。

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

namespace 静态变量和动态变量的区别
{
    public  class Teacher
    {
        public const int A=100;//声明正确

        public const int a;//声明错误，没有赋值

        public readonly int B; //Readonly可以在构造函数中初始化

        public readonly int C = 300;//Readonly也可以声明同时进行初始化
        public Teacher()
        {
             B = 200;
        }
    }
}

（2）.const不能声明为static的，因为const是隐式静态的，而readonly可以是静态的也可以是实例的，r实例成员，所以不同的实例有不同的常量值，readonly更灵活。

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

namespace 静态变量和动态变量的区别
{
    public class Student
    {
        private static const int A = 100;//const不能用static修饰

        private readonly int B = 100;//readonly可以用static修饰

    }
}

（3）.const字段是编译时常量，像3.14和0这样的值是编译时常量，所以声明的时候就需要赋值，readonly是运行时常量。在程序运行的时候赋值，因此可以在构造函数中赋值或者在声明的时候赋值。

（4）const既可以被声明为字段也可以在任何函数内部声明，而readonly只能被声明为字段。

4.解释System.String和System.Text.StringBuilder的区别？

String 对象是不可改变的。每次使用 System.String 类中的方法之一时，都要在内存中创建一个新的字符串对象，也就是说对String对象进行修改需要为该新对象分配新的空间。在需要对字符串执行重复修改的情况下，与创建新的 String 对象相关的系统开销可能会非常昂贵。如果要修改字符串而不创建新的对象，则可以使用 System.Text.StringBuilder 类。例如，当在一个循环中将许多字符串连接在一起时，使用 StringBuilder 类可以提升性能。

StringBuilder类并没有String类的功能强大，只提供基本的替换和添加和删除字符串中的文本，但它的工作效率非常高，当定义StringBuilder对象时可以指定内存的内存容量，如果不指定系统就会根据对象初始化时的字符串长度来确定。它有两个主要参数Length和Capacity分别表示字符串的实际长度和字符串占据的内存空间长度。对字符串的修改就是在这个内存中进行的，大大提高了添加和替换的的效率。

StringBuilder sb=new StringBuilder("Hello,Welcome",100);//初始化对象并设置初始容量为100
sb.Append(" to www.csdn.net");
sb.Replace(old,new);//将old替换为new,作用与String.Replace()一样只是不需要在过程中复制字符。
StringBuilder的成员：
StringBuilder sb=new StringBuilder("Hello World") 定义初值为Hello World的值
StringBuilder sb=new StringBuilder(20); 初始化容量为20的空对象。另外StringBuilder还有MaxCapacity属性用来限定对象可以使用的最大容量。默认大约是int.MaxValue（20亿）可以在使用过程中定义sb.MaxCapacity=value;sb.Append(),给当前字符串追加字符串。
sb.AppendFormat()——添加特定格式的字符串
sb.Insert()——插入一个子字符串
sb.Remove()——从当前字符串删除字符
sb.Replace()——替换字符串中指定的字符
sb.ToString()——将sb转化为String 对象

5.什么是弱类型编程语言？var修饰的数据变量是强类型还是弱类型？

　　强类型语言也称为强类型定义语言。是一种总是强制类型定义的语言，要求变量的使用要严格符合定义，所有变量都必须先定义后使用。

ava、C#、C++等都是强制类型定义的。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。

例如你有一个整数，如果不显式地进行转换，你不能将其视为一个字符串。

　　与其相对应的是弱类型语言：数据类型可以被忽略的语言。它与强类型定义语言相反，一个变量可以赋不同数据类型的值。

弱类型语言也称为弱类型定义语言。与强类型定义相反。像js，php等就属于弱类型语言。

　　var修饰的数据变量是弱类型。

6.描述var，onject和dynamic的区别是什么？

首先三者都能够对声明的变量赋任何类型的值，var声明的变量在赋值的那一刻就决定了它是什么类型，所有的类型都派生自object. 所以它可以赋值为任何类型，dynamic不是在编译时候确定实际类型的, 而是在运行时。

var是C# 3中引入的，其实它仅仅只是一个语法. var本身并不是一种类型, 其它两者object和dynamic是类型。

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

namespace VarObjectDynamic
{
    class Program
    {
        static void Main(string[] args)
        {
            var a = 10;//var声明的变量在赋值的那一刻就决定了它是什么类型

            object b = 20;//所有的类型都派生自object. 所以它可以赋值为任何类型

            dynamic c = "hello";//dynamic不是在编译时候确定实际类型的, 而是在运行时。

            //所以下面的代码是能够通过编译的，但是会在运行时报错
            c++;
            Console.WriteLine(a);
            Console.WriteLine(b);
            Console.WriteLine(c);
        }
    }
}

7.值类型和引用类型的区别是什么？

C#详解值类型和引用类型区别

在C#中值类型的变量直接存储数据，而引用类型的变量持有的是数据的引用，数据存储在数据堆中。

常见的值类型包括：byte，short，int，long，float，double，decimal，char，bool 和 struct ，值类型变量声明后，不管是否已经赋值，编译器为其分配内存。

引用类型：class（类），string，interface（接口），delegate(委托)。当声明一个类时，只在栈中分配一小片内存用于容纳一个地址(等new实例后堆上的地址将保存到该空间)，而此时并没有为其分配堆上的内存空间。当

使用 new 创建一个类的实例时，分配堆上的空间，并把堆上空间的地址保存到栈上分配的小片空间中。值类型的实例通常是在线程栈上分配的（静态分配），但是在某些情形下可以存储在堆中。引用类型的对象总是在进

程堆中分配（动态分配）。

盗用一下大佬的图

值类型：

引用类型：@为存放的堆空间的地址

引用类型和值类型相同点：

（1）引用类型可以实现接口，值类型当中的结构体也可以实现接口；

（2）引用类型和值类型都继承自System.Object类。

范围方面

（1）C#的值类型包括：结构体（数值类型、bool型、用户定义的结构体），枚举，可空类型。

（2）C#的引用类型包括：数组，用户定义的类、接口、委托，object，字符串。

内存分配方面：

（1）数组的元素不管是引用类型还是值类型，都存储在托管堆上。

（2）引用类型在栈中存储一个引用，其实际的存储位置位于托管堆。简称引用类型部署在托管推上。而值类型总是分配在它声明的地方：作为字段时，跟随其所属的变量（实例）存储；作为局部变量时，存储在栈上。

（栈的内存是自动释放的，堆内存是在NET中会由GC来自动释放）

适用场合

（1）值类型在内存管理方面具有更好的效率，并且不支持多态，适合用做存储数据的载体；引用类型支持多态，适合用于定义应用程序的行为。

引用类型可以派生出新的类型，而值类型不能，因为所有的值类型都是密封（seal）的；
引用类型可以包含null值，值类型不能（可空类型功能允许将 null 赋给值类型，如 int? a = null; ）；
引用类型变量的赋值只复制对对象的引用，而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时，将复制包含的值。

值得注意的是，引用类型和值类型都继承自System.Object类。不同的是，几乎所有的引用类型都直接从System.Object继承，而值类型则继承其子类，即直接继承System.ValueType。即System.ValueType本身是一个类类

型，而不是值类型。其关键在于ValueType重写了Equals()方法，从而对值类型按照实例的值来比较，而不是引用地址来比较。

8.Ref和out修饰的参数分别代表什么意思？

ref 关键字使参数按引用传递。其效果是，在方法中对参数的任何更改都将反映在该变量中。若要使用 ref 参数，则方法定义和调用方法都必须显式使用 ref 关键字。

out 关键字会导致参数通过引用来传递。这与 ref 关键字类似，不同之处在于 ref 要求变量必须在传递之前进行初始化，而out是要把参数清空，就是说你无法把一个数值从out传递进去，out进去后，参数的数值为空，所以离

开当前方法前必须对out修饰的变量赋一次值。若要使用 out 参数，方法定义和调用方法都必须显式使用out 关键字。

如上所示，使用ref传递参数，参数必须要初始化。

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

namespace ref和out
{
    class Program
    {
        static void Main(string[] args)
        {
            int b=1;
            Method1(ref b);
            Console.WriteLine("b="+b);//输出100
            int c;
            Method2(out c);
            Console.WriteLine("c="+c);//输出200
            Console.ReadLine();
        }

        static void Method1(ref int a)
        {
            a = 100;
        }

        static void Method2(out int a)
        {
            a = 300;//必须在离开方法前对a赋值，否则回报错
        }
    }
}

9.什么是后期绑定或者晚期绑定，如何实现后期绑定？

后期绑定又可以称为动态绑定（dynamic binding），需要使用System.Reflection，动态地获取程序集里封装的方法、属性等。这种后期绑定的方法大量的被使用在IDE和UI设计中，后期绑定的优点是可

以保存对任何对象的引用。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace Binding
{
    class Program
    {
        static void Main(string[] args)
        {
            Type _type = Type.GetType("Binding.Employee");
            Console.WriteLine(_type.FullName);
            Console.WriteLine(_type.Namespace);
            Console.WriteLine(_type.Name);

            Console.WriteLine("****************************程序集中的所有信息集合***************************");
            Console.WriteLine("****************************程序集中的所有属性信息***************************");
            PropertyInfo[] info = _type.GetProperties();//获取属性信息
            foreach (PropertyInfo propinfo in info)
            {
                Console.WriteLine(propinfo.Name);
            }
            Console.WriteLine("****************************程序集中的所有方法信息***************************");
            MethodInfo[] methods = _type.GetMethods();//获取方法
            foreach (MethodInfo methodinfo in methods)
            {
                Console.WriteLine(methodinfo.Name+""+"\t"+methodinfo.ReturnType.Name);//获取此方法名和方法返回类型
            }

            Console.Read();
        }
    }
    public class Employee
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public float Salary { get; set; }

        public Employee()
        {
            ID = -1;
            Name = string.Empty;
            Salary = 0;
        }
        public Employee(int id, string name, float salary)
        {
            ID = id;
            Name = name;
            Salary = salary;
        }
       

    }
}

输出结果为：

Binding.Employee
Binding
Employee
****************************程序集中的所有信息集合***************************
****************************程序集中的所有属性信息***************************
ID
Name
Salary
****************************程序集中的所有方法信息***************************
get_ID  Int32
set_ID  Void
get_Name        String
set_Name        Void
get_Salary      Single
set_Salary      Void
Equals  Boolean
GetHashCode     Int32
GetType Type
ToString        String

每个属性都有set和get方法

10.描述一下new关键字的三种用法？

在 C# 中，new 关键字可用作运算符、修饰符或约束。
1）new 运算符：用于创建对象和调用构造函数。
2）new 修饰符：在用作修饰符时，new 关键字可以显式隐藏从基类继承的成员。
3）new 约束：用于在泛型声明中约束可能用作类型参数的参数的类型。

第一种用法就不介绍了，下面介绍第二种和第三种用法

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

namespace new关键字三种用法
{
    //用法2
    public class Father
    {
        public string  Name { get; set; }
        public int Age { get; set; }
        public int Height { get; set; }
        public string Job { get; set; }
        public void Talk()
        {
            Console.WriteLine("Father is talking");
        }
    }
}

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

namespace new关键字三种用法
{
    public  class Son:Father
    {
       new public string Job { get; set; }//隐藏和基类中的同名属性
       new  public void Talk()   //隐藏和基类中的同名方法
        {
            Console.WriteLine("Son is talking");
        }
    }
}

用法3

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

namespace new关键字三种用法
{
    public class Teacher
    {
        //如果有了有参构造函数，那么无参构造函数要显示的写出来，如果没有有参构造函数，系统会默认有无参构造函数，无参构造函数可写可不写
        public Teacher()
        {

        }
        public Teacher(string name)
        { 

        }
    }
}

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

namespace new关键字三种用法
{
    class Program
    {
        static void Main(string[] args)
        {
            MyClass<Teacher> myClass = new MyClass<Teacher>();
            myClass.test1();
            Console.ReadLine();
        }

    }
    //使用new关键字修饰的T必须要有无参构造函数
    class MyClass<T> where T : new()
    {
        public void test1()
        {
            Console.WriteLine("哈哈");
        }
    }
}

11.描述一下接口和基类的区别，定义接口的目的是什么？

使用接口和基类都可以实现多态：

（1）通过继承实现多态，基类类型作为方法的返回值类型，实际上返回的是一个具体的子类对象；基类类型作为方法参数类型实际上传递的是具体的子类对象。

（2）接口实现多态，接口作为方法返回值类型，实际上返回的是一个接口实现类对象；接口类型作为方法参数类型实际上传递的是一个接口实现类对象。

当开发一个软件的时候，可能很多时候设计完一个对象之后，并不需要马上考虑或者不知道这个对象具体怎样编写，只知道他要干什么，但不知道怎么实现，还有一种情况就是团队开发，比如一个项目

设计分为10个模块，10个小组完成，怎么做到各自开发各的模块呢？这时候使用接口就可以解决。接口只有方法规定，但是没有方法的具体实现。

通常实现多态要么通过抽象类。要么通过接口，都遵循里氏替换原则，即父类出现的地方可以使用子类替换。抽象类和接口的区别：

（1）接口侧重的是功能的封装，抽象类侧重的是代码的复用和继承，通常把公共行为放到基类中，然后需要多态的行为放到接口中。

（2）接口更简洁，使用更方便，框架设计中，使用的大都是接口而不是抽象类。

下面见一个例子，具体说明了通过继承实现多态和接口实现多态：

例子1：通过继承实现多态

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

namespace InherianceAndPolymoriphism2
{
    abstract class Person                                                                                                                                                                                                                                                                        
    {
        //公共属性
        public string Name { get; set; }
        public string Id { get; set; }
        public DateTime DateofBirth { get; set; }
        //protected只能供子类使用，也就是只能在子类内部使用，不能通过子类对象去使用
        protected string PhoenNumber { get; set; }
        //构造方法
        public Person() { }
        public Person(string Name,string Id) {
            this.Name = Name;
            this.Id = Id;
        }
        //共同的行为:可以放在父类中
        public void Dowork1() 
        {
            Console.WriteLine($"【调用父类的公共方法】：{Name}正在工作");
        }

        public void Dowork2() {
            Console.WriteLine($"【调用父类的公共方法】：{Name}正在写作");
        }

        //父类私有的成员
        private void PersonDoWork() 
        {
            Console.WriteLine($"{Name}正在泡妞");
        }

        //抽象方法：父类规范一个行为要求(没有方法体)，具体实现由子类来实现,具有强制性，即子类必须要实现该行为
        //抽象方法只能包含在抽象类中，但是抽象类可以不包含抽象方法，且抽象类不能通过new构造
        public abstract void Have();

        //虚方法：父类可以对该方法有实现，子类也可以对该方法进行重写，不具有强制性，即子类也可以对该方法不进行重写
        public virtual void Sleep() 
        {
            Console.WriteLine($"【父类实现的虚方法】：{Name}正在睡觉");
        }
    }
}

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

namespace 继承和多态
{
     public  class Student:Person
    {
        //属性
        public int StudentId { get; set; }
        public string ClassName { get; set; }
        //构造方法
        public Student() { }
        public Student(string name, string id, string ClassName, int StudentId) : base(name, id)
        {
            //base.Name = name;
            //base.Id = id;  //或者这样继承，不过上述继承参数的方式写比较简便
            this.ClassName = ClassName;
            this.StudentId = StudentId;
        }
        //实现抽象类方法:关键字为override，必须实现
        public override void Have()
        {
            Console.WriteLine($"【Student子类实现父类中的抽象方法】：{Name}正在吃饭");
        }

        //重写虚方法,关键字为override
        //父类中的虚方法不调用，除非子类主动调用base.Sleep(),父类中的虚方法既可以在父类中实现，也可以在子类中进行重写，或者两者都不实现
        public override void Sleep()
        {
            Console.WriteLine($"【Student子类重写父类中的虚方法】:{Name}正在睡觉");
            base.Sleep();//子类调用父类的虚方法
        }
    }
}

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

namespace 继承和多态
{
    class Program
    {
        static void Main(string[] args)
        {
            Student student = new Student();
            Person p = new Student();//里氏替换原则
            //父类作为方法返回值类型，实际返回的是一个具体的子类对象；/父类作为方法参数类型，实际传递的是一个具体的子类对象
            p = TestStudent(student);
            Console.ReadKey();
        }
        private static Person TestStudent(Person p)
        {
            p.Name = "小唐";
            //调用父类的公共方法,无法调用私有方法
            p.Dowork1();
            p.Dowork2();
            //调用抽象方法
            p.Have();
            p.Sleep();
            return p;
        }

    }
}

输出结果：

【调用父类的公共方法】：小唐正在工作
【调用父类的公共方法】：小唐正在写作
【Student子类实现父类中的抽象方法】：小唐正在吃饭
【Student子类重写父类中的虚方法】:小唐正在睡觉
【父类实现的虚方法】：小唐正在睡觉

例子2：通过接口实现多态

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

namespace 继承和多态
{
    abstract public  class Person
    {
        //公共属性
        public string Name { get; set; }
        public string Id { get; set; }

        //构造方法
        public Person() { }
        public Person(string Name, string Id)
        {
            this.Name = Name;
            this.Id = Id;
        }
       
    }
}

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

namespace 继承和多态
{
    //定义演讲接口
    public interface IMeeting
    {
        //规定行为：行为不能有方法体，且不能加public

        /// <summary>
        /// 演讲
        /// </summary>
        void Speech();

        /// <summary>
        /// 谈话
        /// </summary>
        void Talk();
    }
}

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

namespace 继承和多态
{
    //定义教学接口
    public  interface ITeach
    {
        /// <summary>
        /// 授课
        /// </summary>
        void Lecture();

        /// <summary>
        /// 教学研究
        /// </summary>
        void StudyCourse();
    }
}

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

namespace 继承和多态
{
    public class Teacher : Person, ITeach
    {
        public override void Have()
        {
            Console.WriteLine($"{Name}正在吃饭");
        }

        public void Lecture()
        {
            Console.WriteLine($"{Name}正在授课");
        }

        public void StudyCourse()
        {
            Console.WriteLine($"{Name}正在教学研究");
        }
    }
}

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

namespace 继承和多态
{
    public class President : Person,IMeeting
    {
        //实现抽象类方法
        public override void Have()
        {
            Console.WriteLine($"{Name}正在吃饭");
        }

        //实现接口
        public void Speech()
        {
            Console.WriteLine($"{Name}正在演讲");
        }
        //实现接口
        public void Talk()
        {
            Console.WriteLine($"{Name}正在谈话");
        }
    }
}

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

namespace 继承和多态
{
    class Program
    {
        static void Main(string[] args)
        {
            //里氏替换原则
            IMeeting meeting1 = new President() { Name = "唐主任" };
            ITeach teach1 = new Teacher() { Name = "唐老师" };
            TestIMeeting(meeting1);
            TestITeach(teach1);
            meeting1.Speech();
            teach1.Lecture();
            Console.ReadKey();
        }
      
        //接口实现多态方式一：接口作为方法参数类型，实际传递的是接口的实现类对象President
        private static IMeeting TestIMeeting(IMeeting meeting)
        {
            //接口实现多态方式二：接口作为方法返回值类型，实际返回的是接口的实现类对象President
            return new President();
        }

        //接口实现多态方式一：接口作为方法参数类型，实际传递的是接口的实现类对象Teacher
        private static ITeach TestITeach(ITeach teach)
        {
            //接口实现多态方式二：接口作为方法返回值类型，实际返回的是接口的实现类对象Teacher
            return new Teacher();
        }
    }
}

输出结果：

唐主任正在演讲
唐老师正在授课

12.什么是委托，委托和事件的关系是什么？

委托是一种程序特性，委托可代表一个或者多个同类型的方法，简单的说委托就是方法的变量，能够代表方法。委托的使用步骤如下：

【1】声明委托，定义一个方法的“样子”，也就是我们说的原型，就是指方法的返回值类型、方法的参数类型和个数。

【2】根据委托编写具体的方法

【3】创建委托变量

【4】委托变量关联具体方法（多路委托，使用+=关联多个方法，调用委托的时候将会按顺序执行各个方法）

【5】调用委托

委托的应用：当你在对象之间传递数据的时候，普通方法根本搞不定，这时候使用委托一定能够搞定，主要用在跨线程访问中，例如：

正常情况下：在A对象中创建了B对象，这时候如果B对象中有一个公共行为C，那么在A中是可以调用的

class A

{

B b=new B();

void MyMethod()

{

b.C();

}

void NewMethod()

{

}

问题是如果想在B中调用A中的行为NewMethod是否可以？当然不行！但是通过委托是可以的。

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

namespace 委托
{
    public class A
    {
        B b = new B();
        public void MyMethod()
        {
            b.C();
            //【4】将委托变量关联具体方法
            b.newMethodDelegate += NewMethod;
            //通过委托实现b调用A中的方法NewMethod
            b.B_NewMethod();
        }

        void NewMethod() 
        {
            Console.WriteLine("执行A中的NewMethod方法");
        }
    }

    //【1】声明委托
    public delegate void NewMethodDelegate();
}

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

namespace 委托
{
    public class B
    {
        //【3】创建委托变量
        public NewMethodDelegate newMethodDelegate ;
        public void C() 
        {
            Console.WriteLine("执行B中的C方法");
        }
        //【5】调用委托
        public void B_NewMethod()
        {
            newMethodDelegate();
        }
    }
}

输出结果：

执行B中的C方法
执行A中的NewMethod方法

事件概念：事件其实是对象对外界信息的刺激，产生的一种消息响应机制。本质上事件其实是委托的进一步包装。

随便选取一个按钮事件做例子：

【1】声明委托

public delegate void EventHandler(object sender, EventArgs e);

【2】定义一个委托事件

public event EventHandler Click;

【3】关联委托

this.btn_Login.Click += new System.EventHandler(this.btn_Login_Click);//将事件和方法关联

事件和委托对比不同点：

第一、事件无法直接赋值，比如事件=null；会出现编译错误，而委托可以。

好处：避免用户对事件直接操作，比如Click事件，如果允许Click=null，会把底层代码清除！可以起到保护。

委托相对太“开放”。

第二、event对象没有invoke（）方法，只能通过使用括号的方式来运行。

委托和事件的选择：

第一、正常解决问题，你使用委托和事件没有什么本质区别。所以，我们建议是使用委托。

第二、如果我们做控件二次开发，扩展控件的事件的时候，那必须用事件。

13.描述一下创建并启动一个线程的基本过程？

14什么是序列化，序列化常用的三种格式是什么？

如果我们给自己写的类标识[Serializable]特性，我们就能将这些类序列化。除非类的成员标记了[NonSerializable]，序列化会将类中的所有成员都序列化。

（1）BinaryFormatter序列化：将对象序列化二进制流格式。

（2）SoapFormatter序列化：SOAP是一种轻量的、简单的、基于XML的协议，它被设计成在WEB上交换结构化的和固化的信息。 SOAP 可以和现存的许多因特网协议和格式结合使用，包括超文本传输协议（HTTP），简单邮件传输协议（SMTP），多用途网际邮件扩充协议（MIME）。SOAP序列化的主要优势在于可移植性。SoapFormatter把对象序列化成SOAP消息或解析SOAP消息并重构被序列化的对象。

（3）XML序列化方式：将对象序列化为XML文件。

15.Trace和Debug类的作用是什么，二者有什么区别？

在 C# 语言中允许使用Trace和Debug类输出程序运行时的调试信息，类似于使用 Console.WriteLine 的方式向控制台输出信息。
所谓调试信息是程序员在程序运行时需要获取的程序运行的过程，以便程序员更好地解决程序中出现的问题，这种调试也被称为是非中断调试。

需要注意的是当程序在 Debug 状态下执行时使用 Debug 类和Trace类均可以在输出窗口中显示输出信息，而在 Release 状态下执行时只有 Trace 类输出的内容才会显示在输出窗口中。

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Trace和Debug
{
    class Program
    {
        static void Main(string[] args)
        {
            Trace.WriteLine("Trace");
            Debug.WriteLine("Debug");
            Console.ReadKey();
        }
    }
}

Debug调试状态下的输出：

Release状态下的调试输出：

16WCF框架解决的是什么问题？

17.WCF中的ABC分别指的是什么？

18.描述WCF中三种服务实例上下文模式？

19.WPF绑定数据的4种模式？

20.什么是依赖属性，其作用是什么？

21.什么是逻辑树？可视树？他们和默认模板的关系是什么？

posted @ 2021-01-22 16:49 WellMandala 阅读(522) 评论(0) 编辑收藏举报

刷新页面返回顶部

C#面试题基础

C#详解值类型和引用类型区别

公告