My Blog(学习笔记)

读取操作：

由于1处是有 key 的，所以读取的时候只需要：

string sourceFolder = ConfigurationManager.AppSettings["sourceFolder"];

而 2 处（数据库连接字符串）没有key，所以读取的时候：

string CustomDB = ConfigurationManager.ConnectionStrings["CustomDB"].ConnectionString;

当然，如果你需要多个连接字符串，可以像3处一样，增加即可

写入操作：

//写入<add>元素的Value
    config.AppSettings.Settings["name"].Value = "fx163";
    //增加<add>元素
    config.AppSettings.Settings.Add("url", "http://www.fx163.net");
    //删除<add>元素
    config.AppSettings.Settings.Remove("name");
    //一定要记得保存，写不带参数的config.Save()也可以
    config.Save(ConfigurationSaveMode.Modified);
    //刷新，否则程序读取的还是之前的值（可能已装入内存）
    System.Configuration.ConfigurationManager.RefreshSection("appSettings");

11.重写和重载的区别?

重写方法：关键字用override修饰，派生类重写基类的方法，方法命名、返回类型，参数必须相同

class BaseClass
{
    public virtual void Method()
    {
        Console.WriteLine("BaseClass.Method()");
    }
}

class DerivedClass : BaseClass
{
    public override void Method()
    {
        Console.WriteLine("DerivedClass.Method()");
    }
}


BaseClass obj = new DerivedClass();
obj.Method(); // 输出 "DerivedClass.Method()"

重载方法：方法名必须相同，参数列表必须不相同，返回类型可以不相同。

12.C#中有没有静态构造函数，如果有是做什么用的？

特点： 静态构造函数既没有访问修饰符，也没有参数。
在创建第一个实例或引用任何静态成员之前，将自动调用静态构造函数来初始化类。
无法直接调用静态构造函数。
在程序中，用户无法控制何时执行静态构造函数。
用途 : 当类使用日志文件时，将使用这种构造函数向日志文件中写入项。

13.怎样理解静态变量？静态成员和非静态成员的区别？

• 生命周期：静态成员的生命周期和类相同，随着类的加载而创建，随着类的卸载而销毁；非静态成员的生命周期和实例相同，随着实例的创建而创建，随着实例的销毁而销毁。
• 创建方式：静态成员可以直接被类访问，而不需要创建类的实例；非静态成员必须创建类的实例后才能

14.属性能在接口中声明吗？

可以，不能有访问修饰符，不能初始化赋值。

interface IMyInterface
{
    int Property { get; set; }
}

在接口中声明的属性只包含访问器，而不包含属性值。因此，在接口中声明的属性是抽象的，必须在实现接口的类中进行具体实现。

class MyClass : IMyInterface
{
    private int _property;

    public int Property
    {
        get { return _property; }
        set { _property = value; }
    }
}

在 C# 中，接口中的属性被称为索引器。我们可以使用下面的语法访问索引器：

IMyInterface obj = new MyClass();
int value = obj.Property;
obj.Property = 42;

15.在项目中为什么使用接口？接口的好处是什么？什么是面向接口开发？

接口是一种约束，描述类的公共方法/公共属性，不能有任何的实现

好处是：结构清晰，类之间通信简单易懂，扩展性好，提高复用性。

面向interface编程，原意是指面向抽象协议编程，实现者在实现时要严格按协议来办。

16.什么时候用重载？什么时候用重写？

当一个类需要用不同的实现来做同一件事情，此时应该用重写，
而重载是用不同的输入做同一件事情

17.静态方法可以访问非静态变量吗？如果不可以为什么？

静态方法和非静态变量不是同一生命周期，静态方法属于类，
非静态变量属于具体的对象，静态方法和具体的对象没有任何关联

18.在.Net中所有可序列化的类都被标记为_?

[serializable]

19.C#中 property 与 attribute的区别，他们各有什么用处，这种机制的好处在哪里？

一个是属性，用于存取类的字段，一个是特性，用来标识类，方法等的附加性质

20.特性( attribute)

它们是可以在程序集、类型、成员或参数上应用的声明性标签，用于提供元数据。这些元数据可以在编译时或运行时使用，并可能会影响编译器或其他工具的行为。
下面是一些 C# 中常见的特性：
使用 [Obsolete] 特性标记过时的类型或成员，然后使用工具来查找和删除这些成员，以便在新的代码中使用更新的版本。

使用 [Conditional] 特性来为某个方法指定条件编译，然后根据编译器的命令行选项或预定义的符号来决定是否编译该方法。

使用 [AttributeUsage] 特性来限制特性的使用范围。例如，您可以使用 [AttributeUsage(AttributeTargets.Class)] 来限制特性只能用于类型。

使用 [Serializable] 和 [NonSerialized] 特性来指定类型或字段是否可序列化，以便在运行时将对象的状态保存到文件中或从文件中恢复。

使用 [DllImport] 特性来标记方法为从本机 DLL 导入的，以便在托管代码中调用本机函数。

21.当使用new B()创建B的实例时，产生什么输出？

 using System;
    class A
    {
          public A()
          {
                PrintFields();
          }
          public virtual void PrintFields(){}
      }
      class B:A
      {
           int x=1;
           int y;
           public B()
           {
               y=-1;
           }
           public override void PrintFields()
           {
               Console.WriteLine("x={0},y={1}",x,y);
           }
     }

1.B字段的初始化
2.初始化A的字段
3.A的构造函数
4.B的构造函数

答案：x=1,y=0

22.能用foreach遍历访问的对象需要实现 接口或声明方法的类型

答：IEnumerable 、 GetEnumerator。

21.什么是强类型，什么是弱类型？哪种更好些？为什么?

强类型是在编译的时候就确定类型的数据，在执行时类型不能更改，
弱类型在执行的时候才会确定类型。
没有好不好，二者各有好处，强类型安全，因为它事先已经确定好了，而且效率高。

22.using关键字的作用

1.引用命名空间，也可using 别名-

2.释放资源，实现了IDisposiable的类在using中创建，using结束后会自定调用该对象的Dispose方法，释放资源。

23.ref和out有什么区别

1.都是按引用类型进行传递

2.属性不是变量不能作为out、ref参数传递

3.ref参数必须初始化。out不需要初始化

4.作用，当方法有多个返回值时，out非常有用

• 传递方式：ref 和 out 都是使用传址的方式来传递参数的，即将变量的内存地址直接传递给函数。但是，它们之间在传递参数时的限制不同。
  在使用 ref 修饰参数时，必须在调用函数之前对参数进行赋值，否则编译器会报错。
  而在使用 out 修饰参数时，不需要在调用函数之前对参数进行赋值。

24.a.Equals(b)和a==b一样吗？

不一样，a==b仅仅表示a和b值相等，a.Equals(b)表示a与b一致

25.下面这段代码求值

class Class1
    {
        internal static int count = 0;
        static Class1()
        {
            count++;
        }
        public Class1()
        {
            count++;
        }
    }
Class1 o1 = new Class1();
Class1 o2 = new Class1();

静态构造函数是一种特殊的函数，它不能被显式调用，而是在第一次使用类的静态成员或创建类的实例时自动调用。
上面代码，静态构造函数被调用一次，然后构造函数被调用两次，所以答案是3

26.Math.Round(11.5)等於多少? Math.Round(-11.5)等於多少?

Math.Round(11.5)=12

Math.Round(-11.5)=-12

27.&和&&的区别

1.逻辑运算：&和&&都可作逻辑与的运算
&&具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式
&会计算二个表达式
2.位运算
&可以用作位运算，返回结果是int类型

28.i++和++i的区别

i++ 和 ++i 都是自增运算符，它们都可以将变量的值加 1
++i是先给i加1之后将i+1的结果返回
i++是将i的结果返回后，再给i加1

29.as和is的区别

as在转换的同时判断兼容性，如果无法进行转换，返回位null（没有产生新的对象），as转换是否成功判断的依据是是否位null
is只是做类型兼容性判断，并不执行真正的类型转换，返回true或false，对象为null也会返回false。

11.用最有效的方法算出2乘以8等于几？

位运算是最快，使用的是位运算 逻辑左位移<<。 方法是2<<3相当于0000 0000 0000 0010 （2的16位int二进制）左移三位就是 0000 0000 0001 0000（16的二进制）

12.const和readonly有什么区别？

• 修饰对象不同。const即可以修饰类的字段，也可以修饰局部变量；readonly只能修饰类的字段
• const是编译时常量，在编译时确定该值；readonly是运行时常量，在运行时确定该值。
• const默认是静态的；而readonly如果设置成静态需要显示声明
• 修饰引用类型时不同，const只能修饰string或值为null的其他引用类型；readonly可以是任何类型。

13.现有一个整数number，请写一个方法判断这个整数是否是2的N次方

可以使用位运算符来写一个方法来判断一个整数是否是 2 的 N 次方。

可以使用位运算符 & 来判断一个数是否是 2 的倍数。例如

bool IsPowerOfTwo(int number)
{
    return (number & (number - 1)) == 0;
}

14.CTS、CLS、CLR分别作何解释

CTS（Common Type System）是 .NET Framework 中的一部分，它定义了可以在 .NET Framework 应用程序中使用的类型的规范。 CTS 定义了类型的基本特征，包括类型的继承、封装、多态性和可空性等。

CLS（Common Language Specification）是 .NET Framework 中的一部分，它定义了跨语言开发的规范。CLS 定义了哪些语言特性是必须的，以便在 .NET Framework 中的各种语言之间进行交互。

CLR（Common Language Runtime）是 .NET Framework 中的一部分，它是一个虚拟机，负责执行 .NET Framework 应用程序的字节码。CLR 负责加载并执行应用程序的代码，并为应用程序提供服务，包括内存管理、异常处理、安全性、垃圾回收等。

总之，CTS 定义了 .NET Framework 中的类型，CLS 定义了跨语言开发的规范，CLR 负责执行 .NET Framework 应用程序的代码。

15.在.net中，配件的意思是？

程序集。（中间语言，源数据，资源，装配清单）

16.分析下面代码，a、b的值是多少？

string strTmp = "a1某某某";
int a = System.Text.Encoding.Default.GetBytes(strTmp).Length;
int b = strTmp.Length;

现在一般编码是UTF8
汉字占3个byte，所以a=1+1+3+3+3=11
b是5

18.静态成员和非静态成员的区别

1.静态成员用static修饰符声明

2.不带static的变量时非静态变量，在对象被实例化时创建，通过对象进行访问，

3.静态方法里不能使用非静态成员，非静态方法可以使用静态成员

4.静态成员属于类，而不属于对象

19.c#可否对内存直接操作

C# 可以对内存进行直接操作。在 C# 中，你可以使用指针来访问内存。指针是一种特殊的变量，它存储了一个内存地址，指向一个值的存储位置。

使用指针可以直接访问内存，而不是通过变量名间接访问。使用指针可以提高程序的性能，因为它可以直接访问内存，而不需要通过函数调用来访问。

使用指针需要注意几点：

• 需要在程序中启用指针。要使用指针，必须在程序的开头使用 unsafe 关键字来启用指针。
• 使用指针需要注意越界访问。使用指针可能会导致越界访问，即访问了未分配给程序的内存。
• 使用指针需要谨慎。使用指针可以提高程序的性能，但是也会增加程序的复杂度，并且容易出错。

unsafe
{
    int i = 10;
    int* p = &i;
    Console.WriteLine(*p); // 输出 10
}

20.short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

s1+1不能显式转换成short类型，可以修改为s1 =(short)(s1 + 1) 。
short s1 = 1; s1 += 1正确： [+= ] 运算符会将1转换成short类型再进行运算

1. 字符串中string str=null和string str=””和string str=string.Empty的区别？

string.Empty相当于“”,Empty是一个静态只读的字段。 string str=”” ,初始化对象，并分配一个空字符串的内存空间 string str=null,初始化对象，不会分配内存空间

2. byte b = ‘a’; byte c = 1; byte d = ‘ab’; byte e = ‘啊’; byte g = 256; 这些变量有些错误是错再哪里?

1byte =8bit，1个汉字=2个byte，1个英文=1个byte=8bit
而且只能赋值0~255的数字，如果赋值字符类型需要强制转换
所以只有c是对的

3.string和StringBuilder的区别,两者性能的比较

string是一种不可变的序列，它的值一旦被赋值就不能更改。

StringBuilder是一种可变的序列，它可以通过调用方法来修改它的值。

在性能方面，当需要进行大量的字符串操作时，StringBuilder比string要快。这是因为每次对string的修改操作都会创建一个新的字符串对象并复制原有字符串的内容，这需要额外的时间和内存。相比之下，StringBuilder在修改内容时只是在原有的内存上进行修改，因此具有更好的性能。

不过，在进行少量字符串操作的情况下，使用string也是可以的，因为这时候差别不是很明显。此外，如果你不需要对字符串进行修改，那么使用string是更好的选择，因为它比StringBuilder更安全。

4.什么是扩展方法？

一句话解释，扩展方法使你能够向现有类型“添加”方法，无需修改类型

按扩展方法必须满足下面条件

• 必须要静态类中的静态方法
• 第一个参数的类型是要扩展的类型，
• 并且需要添加this关键字以标识其为扩展方法

public static class StringExtensions
{
    public static string Reverse(this string s)
    {
        char[] charArray = s.ToCharArray();
        Array.Reverse(charArray);
        return new string(charArray);
    }
}

string s = "Hello, World!";
string reversed = s.Reverse();  // "!dlroW ,olleH"

5.byte a =255;a+=5;a的值是多少？

答案是：4

6.什么是装箱和拆箱？

装箱就是隐式地将一个值类型转换成引用类型，如：

int a = 1;
object objecta = a;

拆箱就是将引用类型转换成值类型，如：

int b = (int)objecta;

7.值类型和引用类型的区别

值类型存储的是变量的值，它们包括数值类型、枚举类型和布尔类型。例如，当你声明一个 int 类型的变量时，它就是一个值类型变量。

引用类型存储的是对象的地址，它们包括类类型、接口类型、数组类型和委托类型。例如，当你声明一个类的实例时，它就是一个引用类型变量。

有几个明显的区别：

• 值类型存储在栈内存中，引用类型存储在堆内存中。
• 值类型直接存储值，引用类型存储的是对象的地址。
• 值类型的变量不能为 null，引用类型的变量可以为 null。
• 值类型的变量在赋值时进行值复制，引用类型的变量在赋值时复制的是地址。

8.new关键字的作用?

(1)运算符：创建对象实例

List<int> ints = new List<int>();

(2)修饰符：在派生类定义一个重名的方法，隐藏掉基类方法

public class BaseClass
{
    public virtual void DoWork()
    {
        Console.WriteLine("BaseClass.DoWork");
    }
}

public class DerivedClass : BaseClass
{
    public new void DoWork()
    {
        Console.WriteLine("DerivedClass.DoWork");
    }
}

// 输出 "DerivedClass.DoWork"
DerivedClass derived = new DerivedClass();
derived.DoWork();

(3)约束：泛型约束定义，约束可使用的泛型类型，参数(T)必须具有一个可调用的无参数构造函数,如：

public class MyClass<T> where T : new()
{
    public T CreateInstance()
    {
        return new T();
    }
}

// 使用 MyClass<T>
MyClass<MyType> obj = new MyClass<MyType>();
MyType instance = obj.CreateInstance();

9.int?和int有什么区别?

int？为可空类型，默认值可以是null

int默认值是0

int?是通过int装箱为引用类型实现

10. C#中的委托是什么？

一句话解释就是：将方法当作参数传入另一个方法的参数。 .net中有很多常见的委托如：Func 、Action 作用：提高方法的扩展性

class Calculator
{
    public int Add(int x, int y)
    {
        return x + y;
    }
}

delegate int CalculatorDelegate(int x, int y);

Calculator calculator = new Calculator();
CalculatorDelegate calculatorDelegate = calculator.Add;

也可以这样

CalculatorDelegate calculatorDelegate = (x, y) => x + y;