20230919 .NET面经

SQL

IQuerable 和 IEnumerable 的主要区别？

https://stackoverflow.com/questions/252785/what-is-the-difference-between-iqueryablet-and-ienumerablet

So the difference between IQueryable and IEnumerable is about where the filter logic is executed. One executes on the client side and the other executes on the database.

So if you work with only in-memory data collection, IEnumerable is a good choice, but if you want to query data collection which is connected with database IQueryable is a better choice as it reduces network traffic and uses the power of SQL language.

Id name, 删除重复数据

这道题没答上来有点可惜了...

DELETE FROM A
WHERE id NOT IN (
    SELECT MIN(id)  -- 保留name列最小id值的行
    FROM A
    GROUP BY name
)

把一个表里的列装到另一个表里

将表A中s1列包含'abc'的行的s2和s3两列插入到表B作为s1和s2两列

INSERT INTO B (s1, s2)
SELECT s2, s3 FROM A
WHERE s1 LIKE '%abc%';

select * A,B多少行列?

行：rowA * rowB ，列：rowA + rowB

笛卡尔积：

乐观锁

乐观锁是一种并发控制机制，用于解决多个线程同时修改同一数据时可能导致的数据不一致问题。常见的实现乐观锁的方式是通过版本控制机制，以下是一种常见的实现方法：

1. 添加版本字段：在需要进行并发控制的数据表中，添加一个用于记录版本号的字段。这个字段可以是一个整数或时间戳类型。
2. 读取数据和版本号：在读取数据时，同时获取当前数据的版本号。
3. 进行数据修改：当要对数据进行修改时，首先检查当前持有的版本号是否与最新的版本号一致。可以通过将要修改的数据的版本号与读取时获取的版本号进行比较。
4. 乐观锁冲突处理：

   • 如果版本号一致，说明没有其他线程修改过数据，可以进行修改操作，并更新版本号。

   • 如果版本号不一致，说明数据已经被其他线程修改过，可能存在并发冲突。可以选择取消当前操作、重试操作或执行其他相关的处理逻辑。

推理题

100盏灯

大厅里有100盏灯，每盏灯都编了号码，分别为1-100。每盏灯由一个开关来控制。（开关按一下，灯亮，再按一下灯灭。开关的编号与被控制的灯相同。）开始时，灯是全灭的。现在按照以下规则按动开关。

第一次，将所有的灯点亮。

第二次，将所有2的倍数的开关按一下。

第三次，将所有3的倍数的开关按一下。

以此类推。第N次，将所有N的倍数的开关按一下。

问第100次按完以后，大厅里还有几盏灯是亮的。

依次写下去，就可以发现，每个灯被操作的步骤，其实为此灯编号的因数。

如灯36被操作的步骤:

(1, 36), (2, 18), (3, 12), (4, 9), (6, 6), (9, 4), (12, 3), (18, 2) (36, 1)

此时题目转化为求[1-100]100个数中，因数个数为奇数的数的数量是多少。

ref: https://www.cnblogs.com/dhf327/p/4773672.html

我们注意到，求一个数因数的过程，是从1开始到其平方根，除平方根外，其他的因数都是成对的出现，也就是只有平方数的因数是奇数个！

100以内的平方数只有10个，分别是1，4，9，16，25，36，49，64，81，100，所以上述题目的最后结果是10个灯最后是亮着的。

编程题

如何实现一个可以自定义的可以进行foreach的集合

• 创建集合类实现IEnumerable接口的GetEnumerator方法返回一个迭代器

• 创建迭代器类实现IEnumerator接口的MoveNext、Reset、Current方法

• foreach：

  var enumerator = collection.GetEnumerator();
  while (enumerator.MoveNext())
  {
  	Console.WriteLine(enumerator.Current);
  }
  

// 自定义集合类
public class MyCollection : IEnumerable
{
    private object[] items;

    public MyCollection()
    {
        items = new object[3];
        items[0] = "Apple";
        items[1] = "Banana";
        items[2] = "Orange";
    }

    // 实现 IEnumerable 接口的 GetEnumerator() 方法
    public IEnumerator GetEnumerator()
    {
        return new MyEnumerator(items);
    }
}

// 自定义枚举器类
public class MyEnumerator : IEnumerator
{
    private object[] items;
    private int position = -1;

    public MyEnumerator(object[] collection)
    {
        items = collection;
    }

    // 实现 IEnumerator 接口的 MoveNext() 方法
    public bool MoveNext()
    {
        position++;
        return (position < items.Length);
    }

    // 实现 IEnumerator 接口的 Reset() 方法
    public void Reset()
    {
        position = -1;
    }

    // 实现 IEnumerator 接口的 Current 属性
    public object Current
    {
        get { return items[position]; }
    }
}

如下代码输出是什么？

[TestClass]
public class InheritanceTest
{
    [TestMethod]
    public void test()
    {
        A a = new A();
        B b = new B();
        a.Func2(b);
        b.Func2(a);
    }

    class A
    {
        public virtual void Func1(int i)
        {
            Console.WriteLine(i);
        }

        public void Func2(A a)
        {
            a.Func1(1);
            Func1(5);
        }
    }

    class B : A
    {
        public override void Func1(int i)
        {
            base.Func1(i+1);
        }

        public void Func2(A a)
        {
            a.Func1(1);
            Func1(5);
        }
    }
}
/*
2
5
1
6
*/

实际上是对多态的考察，一个对象的实际类型不由“解释”它的接口/基类类型决定，而是由分配内存时(new)创建的对象决定。