2018年NET面试总结(二)

拼搏现实的明天。 2021-06-26 16:06 454阅读 0赞

##  ##

1.问题：你让工人为你工作7天，回报是一根金条，这个金条平分成相连的7段，你必须在每天结束的时候 给他们一段。如果只允许你两次把金条弄断，你如何给你的工人付费？

> 切成1段,2段,和四段.  
> 1:给出1.  
> 2:给出2,还回1.  
> 3:给出1.  
> 4:给出4,还回3.  
> 5:给出1.  
> 6:给出2,还回1.  
> 7:给出1.

## 不借用第三个变量,怎么把a,b的值互换 ##

int  a =10;int b=5;  
        a= a+b;  
        b=a-b;  
        a=a-b;

## 请列出5个常用的jquery操作Dom方法 ##

> 1.三个简单实用的用于 DOM 操作的 jQuery 方法：
> 
> · text() - 设置或返回所选元素的文本内容
> 
> · html() - 设置或返回所选元素的内容（包括 HTML 标记）
> 
> · val() - 设置或返回表单字段的值
> 
> 2.attr()获取属性。当然这两也是可以自己设置值来修改的，
> 
> 3.对html内容的添加。添加新的 HTML 内容
> 
> 我们将学习用于添加新内容的四个 jQuery 方法：
> 
> · append() - 在被选元素的结尾插入内容
> 
> · prepend() - 在被选元素的开头插入内容
> 
> · after() - 在被选元素之后插入内容
> 
> · before() - 在被选元素之前插入内容
> 
> 4.删除元素/内容
> 
> 如需删除元素和内容，一般可使用以下两个 jQuery 方法：
> 
> · remove() - 删除被选元素（及其子元素）
> 
> · empty() - 从被选元素中删除子元素
> 
> 5.jQuery 操作 CSS
> 
> jQuery 拥有若干进行 CSS 操作的方法。我们将学习下面这些：
> 
> · addClass() - 向被选元素添加一个或多个类
> 
> · removeClass()- 从被选元素删除一个或多个类
> 
> · toggleClass()- 对被选元素进行添加/删除类的切换操作
> 
> · css() - 设置或返回样式属性

--------------------

## `innerHTML`与`innerText`区别 ##

innerHTML指的是从对象的起始位置到终止位置的全部内容,包括Html标签。
    innerText   指的是从起始位置到终止位置的内容,但它去除Html标签。

## `setInterval`和`setTimeout`的使用区别 ##

setInterval在执行完一次代码之后，经过了那个固定的时间间隔，它还会自动重复执行代码，而setTimeout只执行一次那段代码。

## javascript中什么是闭包？如何闭包？ ##

闭包（`Closure`）这个词的意思是**封闭**，将外部作用域中的局部变量封闭起来的**函数对象**称为**闭包**。被封闭起来的变量与封闭它的函数对象有相同的生命周期。

闭包就是能够读取其他函数内部变量的函数。由于在`javascript`中，只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。

> 利用闭包可以给对象设置私有属性并利用特权(`Privileged`)方法访问私有属性。

## Jquery查找id为test的`div`容器中所有`input`标签 ##

$("#test").find("input");

## `var`和`dynamic`的区别 ##

> 1.  var表示“变量的类型是在编译时决定的”， var让你在初始化变量时少输入一些字，编译器会根据右值来推断出变量的类型， var只能用于局部变量的定义，你不能把类的属性定义成 var，也不能把方法的返回值类型或者是参数类型定义成var
> 2.  `dynamic`表示“变量的类型是在运行时决定的”，动态语言运行时`（dynamic language runtime DLR）`是.NET Framework 4 Beta 1中的一组新的API，它提供了对c\#中`dynamic`类型的支持,`dynamic`告诉编译器，根本就别理究竟是啥类型，运行时再推断不迟，`dynamic`类型并没有跳过类型校验，只是延迟到了运行时。如果在运行时，检测到类型不兼容，照样会抛出异常。变量，属性，方法返回值类型及参数类型都可定义为`dynamic`。

你可能在以下情况下使用`dynamic`：

> 1.COM对象
> 
> 2.动态语言(如IronPython，IronRuby等)对象
> 
> 3.反射对象
> 
> 4.C\# 4.0中动态创建的对象

因此，`dynamic`与`var`具有截然不同的含义。

## `Func<T>`、`Action<T>` 的区别和相同 ##

`Func`与`Action`作用几乎一样。只是

> `Func<Result>`有返回类型；  
> `Action<T>`只有参数类型，不能传返回类型。所以`Action<T>`的委托函数都是没有返回值的。  
> `Func`与`Action`都支持`Lambda`的形式调用

Func<string, string> say = m => m + m;
    Console.WriteLine(say("abc"));　　　　//输出abcabc

## 如何防止表单重复提交 ##

> 表单重复提交是在多用户Web应用中最常见、带来很多麻烦的一个问题。有很多的应用场景都会遇到重复提交问题，比如：
> 
> 点击提交按钮两次。  
> 点击刷新按钮。  
> 使用浏览器后退按钮重复之前的操作，导致重复提交表单。  
> 使用浏览器历史记录重复提交表单。  
> 浏览器重复的HTTP请求。  
> 用户提交表单时可能因为网速的原因，或者网页被恶意刷新，致使同一条记录重复插入到数据库中，这是一个比较棘手的问题。我们可以从客户端和服务器端一起着手，设法避免同一表单的重复提交。

1、js禁掉提交按钮。  
2、使用`Post/Redirect/Get`模式。

在提交后执行页面重定向，这就是所谓的`Post-Redirect-Get (PRG)`模式。简言之，当用户提交了表单后，你去执行一个客户端的重定向，转到提交成功信息页面。

这能避免用户按F5导致的重复提交，而其也不会出现浏览器表单重复提交的警告，也能消除按浏览器前进和后退按导致的同样问题。

3、在`session`中存放一个特殊标志。  
4、使用`Cookie`处理

使用`Cookie`记录表单提交的状态，根据其状态可以检查是否已经提交表单。

5、在数据库里添加约束

在数据库里添加唯一约束或创建唯一索引，防止出现重复数据。这是最有效的防止重复提交数据的方法。

## 什么是`ThreadPool`,它的作用和优缺点 ##

> `ThreadPool`(线程池)是一个静态类，它没有定义任何的构造方法()，我们只能够使用它的静态方法，这是因为`ThreadPool`是托管线程池，是由CLR管理的。  
> `ThreadPool`使用`WaitCallback`委托，它所要做的工作是在后台进行的。使工作项的排队和运行更容易，可以给工作者线程传递一个状态对象（提供数据）。状态对象是私有的作用域位于线程层，所以不需要进行同步。  
> `ThreadPool`目标是为了减除线程的初始化开销，实现并行处理。.NET类库中的`ThreadPool`是异步`IO`的基础，比如，在`System.Net.Socket`中，我们可以使用`BeginAccept` , `EndAccept`将`Socket`需要阻塞的操作放到系统的线程池中运行，而在执行结束以后通知主线程。  
> 一个`ThreadPool`里面注册的线程拥有默认的堆栈大小，默认的优先级。并且，他们都存在于多线程空间（`Multithreaded apartment`）中。  
> `ThreadPool`中的`Thread`不能手动取消，也不用手动开始。所以`ThreadPool`并不适用比较长的线程。你要做的只是把一个`WaitCallback`委托塞给`ThreadPool`，然后剩下的工作将由系统自动完成。系统会在`ThreadPool`的线程队列中一一启动线程。  
> 当线程池满时，多余的线程会在队列里排队，当线程池空闲时，系统自动调入排队的线程，以保持系统利用率。

线程池的作用：

> 线程池是为突然大量爆发的线程设计的，通过有限的几个固定线程为大量的操作服务，减少了创建和销毁线程所需的时间，从而提高效率。

> 如果一个线程的时间非常长，就没必要用线程池了(不是不能作长时间操作，而是不宜。)，况且我们还不能控制线程池中线程的开始、挂起、和中止。

> 使用线程池的好处有很多，比如节省系统资源的开销，节省创建和销毁线程的时间等，当我们需要处理的任务较多时，就可以使用线程池

## 编写一个单例(`Singleton`)类 ##

简单安全线程

public sealed class Singleton
    { 
        private static Singleton instance = null;
        private static readonly object padlock = new object();
    
        Singleton()
        { 
        }
    
        public static Singleton Instance
        { 
            get
            { 
                lock (padlock)
                { 
                    if (instance == null)
                    { 
                        instance = new Singleton();
                    }
                    return instance;
                }
            }
        }
    }

## 请使用LINQ语法进行分页,查询第10页数据,每页8条 ##

.Skip(72).Take(8)

//Take是从序列的开头返回指定数量的连续元素，也就是说()里面放的数是多少就返回多少条数据
    //Skip是跳过序列中指定的元素，返回剩余的，也就是说()里面放的数是多少，它就跳过多少
    dtDanAn = dtDanAn.Take(PageSize * CurPage).Skip(PageSize * (CurPage - 1));//进行分页

## `inner join`和`left join`的区别 ##

1、`Left Join`（左联接）

以左表为中心，返回左表中符合条件的所有记录以及右表中联结字段相等的记录——当右表中无相应联接记录时，返回空值。

2、`Right Join`（右联接）

以右表为中心，返回右表中符合条件的所有记录以及左表中联结字段相等的记录——当左表中无相应联接记录时，返回空值。

3、`Inner Join`（等值连接）

返回两个表中联结字段相等的行。

## MVC有几种向页面绑定数据的方法 ##

> 1、指定页面数据的强类型Module  
> 2、使用ViewData绑定到页面  
> 3、使用ViewBag绑定到页面

## MVC自带的缓存怎么实现,`VaryByParam`这个是什么意思 ##

`VaryByParam`：向Action传参时，根据哪些参数对输出进行缓存。

//只当传入的code不同时，会缓存不同的输出
    [OutputCache(Duration = 600, VaryByParam = "code")]
    public ActionResult PositionTree(String code, int ID)
    //对所有传入参数进行不同的缓存
    [OutputCache(Duration = 600, VaryByParam = "*")]
    //缓存与参数无关，此Action只缓存一份
    [OutputCache(Duration = 600, VaryByParam = "none")]

## 列举你熟悉的开源框架,说出他们的优缺点 ##

`Quartz.NET`，`NPOI`，`Lucene.net`，`SuperSocket`，`Newtonsoft.Json`，`Dapper`

--------------------

## C\#合并两个数组 ##

int[] a = {  1, 2, 3, 4, 5 };
    int[] b = {  3, 5, 6 };
    var _list=a.ToList();
    foreach (var item in b) 
    { 
    	if (_list.Contains(item))
    	{ 
    	  _list.Add(item);
            }
    }
    return _list.ToArray();

## `Lambda`加自定义比较器实现两个列表的合并 ##

一次项目有这样的需求，本地存储了json数据，可以转化为对应的List列表，现在需要更新，从服务器那里获取最新的数据更改。总的来说就是本地有个List表，如果数据需要更新，则会向服务器发送请求来获取需要更改的部分List表格，然后客户端这边就要去处理合并完整这次的更新，弄了一个下午，终于搞定，这次来mark一下。

主要推送的数据的两个特性：

> 1.如果之前的列表需要增加，则出现在最新的数据推送List中
> 
> 2.如果数据需要修改的话，则一样推送更新，保持id不变，内容有所改变

示例代码如下：

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace test
    { 
        public class date
        { 
            public int id {  set; get; }
            public string color {  set; get; }
            public string name {  set; get; }
            public decimal price {  set; get; }
    
            public string time {  get; set; }
        }
    
        class MyComparer : IEqualityComparer<date>
        { 
            public bool Equals(date x, date y)
            { 
                return x.id == y.id;
            }
    
            public int GetHashCode(date obj)
            { 
                return obj.id.GetHashCode();
            }
        }
    
        class Program
        { 
            static void Main(string[] args)
            { 
                List<date> list1 = new List<date>() 
                { 
                    new date() {  id = 1, color = "1", name = "name1", price = 1,time="时间" },
                    new date() {  id = 2, color = "2", name = "name2", price = 2,time="时间" },
                    new date() {  id = 3, color = "3", name = "name3", price = 3,time="时间" },
                    new date() {  id = 5, color = "5", name = "name5", price = 5,time="时间" },
                    new date() {  id = 6, color = "6", name = "name8", price = 8,time="时间" }
                };
                List<date> list2 = new List<date>() 
                { 
                    new date() {  id = 1, color = "修改", name = "修改", price = 2,time="时间" },
                    new date() {  id = 8, color = "增加", name = "增加", price = 2,time="时间" }
                };
                var result = list2.Union(list1, new MyComparer());
                foreach (var item in result)
                { 
                    Console.WriteLine("id = {0}, card = {1}, name = {2}, price = {3}", item.id, item.color, item.name, item.price,item.time);
                }
            }
        }
    }

测试的结果为：

![这里写图片描述][c0120857087bdec1d8c36006dff4ffd6.png]

从结果看出，id=1的数据需要修改，所以最新生成的`List`表中id为1的所有属性都是更改后的结果，而在list1中没有id为8的数据，说明这个是需要新增进去的一条记录，因此在最新的List也有了，这次主要用到自定义的比较器，去实现`IEqualityComparer<>`这个接口。另外还用到了`Lambda`表达式

`var result = list2.Union(list1, new MyComparer());`特别是`Union`这个方法的使用，该方法还有很多种用法，这里就举个例子而已啦

## C\#中，抽象类和接口有哪些区别？ ##

相同点：

1.  都不能被**直接实例化**。

不同点 :

> (1)接口只有定义，而抽象类的方法可以在抽象类中被实现。
> 
> (2)接口支持多继承；抽象类不能实现多继承。
> 
> (3)接口是一组行为规范；抽象类是一个不完全的类，着重族的概念。
> 
> (4)接口可以用于支持回调；抽象类不能实现回调，因为继承不支持。
> 
> (5)接口只包含**方法、属性、索引器、事件的签名**，但不能定义字段和包含实现的方法；**抽象类可以定义字段、属性、包含有实现的方法。**
> 
> (6)**接口可以作用于值类型和引用类型；抽象类只能作用于引用类型。例如，`Struct`就可以继承接口，而不能继承类。**
> 
> (8)如果抽象类实现接口，则可以把接口中方法映射到抽象类中作为抽象方法而不必实现，而在抽象类的子类中实现接口中方法

--------------------

> 抽象类中可以有任意个抽象方法（可以没有）
> 
> 抽象类中可以有任意个非抽象方法（可以没有）
> 
> **抽象方法只能定义在抽象类或接口中**
> 
> 抽象类不可以被实例化，但可以被其他类继承
> 
> 当其他类继承了抽象类后必须把抽象类中的抽象方法重写

--------------------

抽象类是可以定义有实现的行为方法，接口才是不能定义有实现的行为方法

**抽象类中可以有非抽象方法（此种方法可以有具体的实现），但抽象类中的抽象方法（带abstract）的，则不可以有实现体。**

抽象类是不能`new`操作，但是可以通过继承调用相应的有实现的行为方法

**接口中所有的方法必须都是抽象的，接口中也可以定义数据成员，但必须是常量。**

--------------------

# C\#中抽象方法与虚方法的区别 #

总结：

> 抽象方法是只有方法名称，没有方法体（也就是没有方法具体实现），非抽象子类必须重写父类抽象方法；
> 
> 虚函数是该方法有方法体，但是子类可以覆盖，也可不覆盖。

--------------------

> （1）虚方法有方法体，抽象方法没有方法体。抽象方法是一种强制派生类覆盖的方法，否则派生类将不能被实例化；
> 
> （2）抽象方法只能在抽象类中声明，虚方法不是；
> 
> （3）非抽象派生类必须重写抽象类中的抽象方法，虚方法则不必要。

## 浅谈C\#抽象方法、虚方法、接口 ##

> 一、Virtual方法（虚方法）
> 
>     virtual 关键字用于在基类中修饰方法。virtual的使用会有两种情况：
>     
>      情况1：在基类中定义了virtual方法，但在派生类中没有重写该虚方法。那么在对派生类实例的调用中，该虚方法使用的是基类定义的方法。
>     
>      情况2：在基类中定义了virtual方法，然后在派生类中使用override重写该方法。那么在对派生类实例的调用中，该虚方法使用的是派生重写的方法。
> 
> 二、Abstract方法（抽象方法）
> 
>     abstract关键字只能用在抽象类中修饰方法，并且没有具体的实现。抽象方法的实现必须在派生类中使用override关键字来实现。请务必将抽象方法放在抽象类中。派生类必须全部实现父类的方法。
> 
> 三、Interface：接口中的方法没有具体实现，也就是没有方法体，必须由继承者去实现而且必须全部实现。

# c\#中接口和类的异同 #

异：

> 不能直接实例化接口，
> 
> 接口不包含方法的实现，
> 
> 接口、类和结构可以从多个接口继承，但是类只能从一个基类继承实现。

同：

> 接口、类和结构可以从多个接口继承，
> 
> 接口类似于抽象基类：继承接口的任何非抽象类型都必须实现接口的所有成员，
> 
> 接口可以包含事件、索引器、方法和属性

# 什么是存储过程，存储过程的作用及优点 #

**存储过程（Stored Procedure）是一组为了完成特定功能的 SQL 语句集，经编译后存储在数据库中。** 用户通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来执行它。存储过程是数据库中的一个重要对象。

**优点**

> ①重复使用。存储过程可以重复使用，从而可以减少数据库开发人员的工作量。
> 
> ②减少网络流量。存储过程位于服务器上，调用的时候只需要传递存储过程的名称以及参数就可以了，因此降低了网络传输的数据量。
> 
> ③安全性。参数化的存储过程可以防止SQL注入式攻击，而且可以将`Grant、Deny`以及`Revoke`权限应用于存储过程。

简单讲：

> 1.存储过程只在创造时进行编译，以后每次执行存储过程都不需再重新编译，而一般SQL语句每执行一次就编译一次,所以使用存储过程可提高数据库执行速度。  
> 2.当对数据库进行复杂操作时(如对多个表进行`Update,Insert,Query,Delete`时)，可将此复杂操作用存储过程封装起来与数据库提供的事务处理结合一起使用。  
> 3.存储过程可以重复使用,可减少数据库开发人员的工作量  
> 4.安全性高,可设定只有某些用户才具有对指定存储过程的使用权 有一点需要注意的是，一些网上盛传的所谓的存储过程要比sql语句执行更快的说法，实际上是个误解，并没有根据，包括微软内部的人也不认可这一点，所以不能作为正式的优点，希望大家能够认识到这一点。

**缺点**

> 1：调试麻烦，但是用 `PL/SQL Developer` 调试很方便！弥补这个缺点。
> 
> 2：移植问题，数据库端代码当然是与数据库相关的。但是如果是做工程型项目，基本不存在移植问题。
> 
> 3：重新编译问题，因为后端代码是运行前编译的，如果带有引用关系的对象发生改变时，受影响的存储过程、包将需要重新编译（不过也可以设置成运行时刻自动编译）。
> 
> 4：如果在一个程序系统中大量的使用存储过程，到程序交付使用的时候随着用户需求的增加会导致数据结构的变化，接着就是系统的相关问题了，最后如果用户想维护该系统可以说是很难很难、而且代价是空前的，维护起来更麻烦。

# 常见模块设计–权限管理 #

> 1.基于 `RBAC（Role-based Access Control）`权限访问控制。也就是说一个用户可以有多个角色，一个角色可以有多个权限，通过将角色和权限分离开来提高设计的可扩展性，通常一个用户有多个角色，一个角色也会属于多个用户（多对多），一个角色有多个权限，一个权限也会属于多个角色（多对多）。
> 
> 2.最简单版本 假设：我们拿到一个用户对象， 可以通过：用户id –>角色id–>角色名称（什么角色）–>权限id –> 权限标识 –>获取权限。最终获取权限获取角色信息。  
> ![这里写图片描述][506c0ae3544c9a4b9edf81426be2fcf0.png]

[c0120857087bdec1d8c36006dff4ffd6.png]: /images/20210626/77cc5a8cc82a4889965f7372107e6883.png
[506c0ae3544c9a4b9edf81426be2fcf0.png]: /images/20210626/d8a7c8e75843437ebbb09638be62a3e7.png