├── LICENSE
└── README.md
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2022 WPFDevelopersOrg
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # WPF 面试题参考 **基础**
2 |
3 |
4 | ## 目录
5 |
6 | 1）[值类型与引用类型](#值类型与引用类型)
7 |
8 | 2）[装箱与拆箱](#装箱与拆箱)
9 |
10 | 3）[string与字符串操作](#string与字符串操作)
11 |
12 | 4）[类与接口](#类与接口)
13 |
14 | 5）[常量、字段、属性、特性与委托](#常量、字段、属性、特性与委托)
15 |
16 | 6）[GC与内存管理](#GC与内存管理)
17 |
18 | 7）[多线程编程与线程同步](#多线程编程与线程同步)
19 |
20 | 8）[线程同步](#线程同步)
21 |
22 | 9）[WPF](#WPF)
23 |
24 | --------------------------------
25 |
26 | ## 值类型与引用类型
27 |
28 | ### **1.值类型和引用类型的区别？**
29 |
30 | 值类型包括简单类型、结构体类型和枚举类型，引用类型包括自定义类、数组、接口、委托等。
31 |
32 | 1、赋值方式：将一个值类型变量赋给另一个值类型变量时，将复制包含的值。这与引用类型变量的赋值不同，引用类型变量的赋值只复制对象的引用（即内存地址，类似`C++`中的指针），而不复制对象本身。
33 |
34 | 2、继承：值类型不可能派生出新的类型，所有的值类型均隐式派生自 `System.ValueType`。但与引用类型相同的是，结构也可以实现接口。
35 |
36 | 3、`null`：与引用类型不同，值类型不可能包含 `null` 值。然而，可空类型功能允许将 `null` 赋给值类型。
37 |
38 | 4、每种值类型均有一个隐式的默认构造函数来初始化该类型的默认值，值类型初始会默认为0，引用类型默认为`null`。
39 |
40 | 5、值类型存储在栈中，引用类型存储在托管堆中。
41 |
42 | ### **2. 结构和类的区别？**
43 |
44 | 结构体是值类型，类是引用类型，主要区别如题1。
45 | 其他的区别：
46 | - 结构不支持无惨构造函数，不支持析构函数，并且不能有`protected`修饰；
47 | - 结构常用于数据存储，类`class`多用于行为；
48 | - `class`需要用`new`关键字实例化对象，`struct`可以不适用`new`关键字；
49 | - `class`可以为抽象类，`struct`不支持抽象；
50 |
51 | ### **3. delegate是引用类型还是值类型？enum、int[]和string呢？**
52 |
53 | enum枚举是值类型，其他都是引用类型。
54 |
55 | ### **4. 堆和栈的区别？**
56 |
57 | 线程堆栈：
58 | - 简称栈 Stack托管堆： 简称堆 Heap值类型大多分配在栈上，引用类型都分配在堆上；
59 | - 栈由操作系统管理，栈上的变量在其作用域完成后就被释放，效率较高，但空间有限。堆受CLR的GC控制；
60 | - 栈是基于线程的，每个线程都有自己的线程栈，初始大小为1M。堆是基于进程的，一个进程分配一个堆，堆的大小由GC根据运行情况动态控制；
61 |
62 | ### **5.“结构”对象可能分配在堆上吗？什么情况下会发生，有什么需要注意的吗？**
63 |
64 | 结构是值类型，有两种情况会分配在对上面：结构作为class的一个字段或属性，会随class一起分配在堆上面；装箱后会在堆中存储，尽量避免值类型的装箱，值类型的拆箱和装箱都有性能损失，下一篇会重点关注；
65 |
66 | ### **6. 理解参数按值传递？以及按引用传递？**
67 |
68 | 按值传递：对于值类型传递的它的值拷贝副本，而引用类型传递的是引用变量的内存地址，他们还是指向的同一个对象。按引用传递：通过关键字out和ref传递参数的内存地址，值类型和引用类型的效果是相同的。
69 |
70 | ### **7. out 和 ref的区别与相同点？**
71 |
72 | out 和 ref都指示编译器传递参数地址，在行为上是相同的；他们的使用机制稍有不同，ref要求参数在使用之前要显式初始化，out要在方法内部初始化；out 和 ref不可以重载，就是不能定义Method(ref int a)和Method(out int a)这样的重载，从编译角度看，二者的实质是相同的，只是使用时有区别；
73 |
74 | ### **8. 有几种方法可以判定值类型和引用类型？**
75 |
76 | 简单来说，继承自System.ValueType的是值类型，反之是引用类型。
77 |
78 | ### **9. C#支持哪几个预定义的值类型？C#支持哪些预定义的引用类型？**
79 |
80 | 值类型：整数、浮点数、字符、bool和decimal引用类型：Object，String
81 |
82 | ### **10. 说说值类型和引用类型的生命周期？**
83 |
84 | 值类型在作用域结束后释放。引用类型由GC垃圾回收期回收。这个答案可能太简单了，更详细的答案在后面的文章会说到。
85 |
86 | ### **11. 如果结构体中定义引用类型，对象在内存中是如何存储的？例如下面结构体中的class类 User对象是存储在栈上，还是堆上？**
87 |
88 | ```C#
89 | public struct MyStruct
90 | {
91 | public int Index;
92 | public User User;
93 | }
94 | ```
95 |
96 |
97 |
98 | MyStruct存储在栈中，其字段User的实例存储在堆中，MyStruct.User字段存储指向User对象的内存地址。
99 |
100 |
101 | ## 装箱与拆箱
102 |
103 |
104 | ### **1.什么是拆箱和装箱？**
105 |
106 | 装箱就是值类型转换为引用类型，拆箱就是引用类型（被装箱的对象）转换为值类型。
107 |
108 | ### **2.什么是箱子？**
109 |
110 | 就是引用类型对象。
111 |
112 | ### **3.箱子放在哪里？**
113 |
114 | 托管堆上。
115 |
116 | ### **4.装箱和拆箱有什么性能影响？**
117 |
118 | 装箱和拆箱都涉及到内存的分配和对象的创建，有较大的性能影响。
119 |
120 | ### **5.如何避免隐身装箱？**
121 |
122 | 编码中，多使用泛型、显示装箱。
123 |
124 | ### **6.箱子的基本结构？**
125 |
126 | 上面说了，箱子就是一个引用类型对象，因此它的结构，主要包含两部分：值类型字段值；引用类型的标准配置，引用对象的额外空间：TypeHandle和同步索引块，关于这两个概念在本系列后面的文章会深入探讨。
127 |
128 | ### **7.装箱的过程？**
129 |
130 | 1.在堆中申请内存，内存大小为值类型的大小，再加上额外固定空间（引用类型的标配：TypeHandle和同步索引块）；2.将值类型的字段值（x=1023）拷贝新分配的内存中；3.返回新引用对象的地址（给引用变量object o）
131 |
132 | ### **8.拆箱的过程？**
133 |
134 | 1.检查实例对象（object o）是否有效，如是否为null，其装箱的类型与拆箱的类型（int）是否一致，如检测不合法，抛出异常；2.指针返回，就是获取装箱对象（object o）中值类型字段值的地址；3.字段拷贝，把装箱对象（object o）中值类型字段值拷贝到栈上，意思就是创建一个新的值类型变量来存储拆箱后的值；
135 |
136 |
137 | ## string与字符串操作
138 |
139 |
140 | ### **1.字符串是引用类型类型还是值类型？**
141 |
142 | 引用类型。
143 |
144 | ### **2.在字符串连加处理中，最好采用什么方式，理由是什么？**
145 |
146 | 少量字符串连接，使用String.Concat，大量字符串使用StringBuilder，因为StringBuilder的性能更好，如果string的话会创建大量字符串对象。
147 |
148 | ### **3.使用 StringBuilder时，需要注意些什么问题？**
149 |
150 | 少量字符串时，尽量不要用，StringBuilder本身是有一定性能开销的；大量字符串连接使用StringBuilder时，应该设置一个合适的容量；
151 |
152 |
153 |
154 | ## 类与接口
155 |
156 | ### **1. 所有类型都继承System.Object吗？**
157 |
158 | 基本上是的，所有值类型和引用类型都继承自System.Object，接口是一个特殊的类型，不继承自System.Object。
159 |
160 | ### **2. 解释virtual、sealed、override和abstract的区别**
161 |
162 | - virtual申明虚方法的关键字，说明该方法可以被重写
163 |
164 | - sealed说明该类不可被继承
165 |
166 | - override重写基类的方法
167 |
168 | - abstract申明抽象类和抽象方法的关键字，抽象方法不提供实现，由子类实现，抽象类不可实例化。
169 |
170 | ### **3. 接口和类有什么异同？**
171 |
172 | 不同点：
173 |
174 | 1、接口不能直接实例化。
175 |
176 | 2、接口只包含方法或属性的声明，不包含方法的实现。
177 |
178 | 3、接口可以多继承，类只能单继承。
179 |
180 | 4、类有分部类的概念，定义可在不同的源文件之间进行拆分，而接口没有。（这个地方确实不对，接口也可以分部，谢谢@xclin163的指正）
181 |
182 | 5、表达的含义不同，接口主要定义一种规范，统一调用方法，也就是规范类，约束类，类是方法功能的实现和集合
183 |
184 | 相同点：
185 |
186 | 1、接口、类和结构都可以从多个接口继承。
187 |
188 | 2、接口类似于抽象基类：继承接口的任何非抽象类型都必须实现接口的所有成员。
189 |
190 | 3、接口和类都可以包含事件、索引器、方法和属性。
191 |
192 | ### **4. 抽象类和接口有什么区别？**
193 |
194 | 1、继承：接口支持多继承；抽象类不能实现多继承。
195 |
196 | 2、表达的概念：接口用于规范，更强调契约，抽象类用于共性，强调父子。抽象类是一类事物的高度聚合，那么对于继承抽象类的子类来说，对于抽象类来说，属于"Is A"的关系；而接口是定义行为规范，强调“Can Do”的关系，因此对于实现接口的子类来说，相对于接口来说，是"行为需要按照接口来完成"。
197 |
198 | 3、方法实现：对抽象类中的方法，即可以给出实现部分，也可以不给出；而接口的方法（抽象规则）都不能给出实现部分，接口中方法不能加修饰符。
199 |
200 | 4、子类重写：继承类对于两者所涉及方法的实现是不同的。继承类对于抽象类所定义的抽象方法，可以不用重写，也就是说，可以延用抽象类的方法；而对于接口类所定义的方法或者属性来说，在继承类中必须重写，给出相应的方法和属性实现。
201 |
202 | 5、新增方法的影响：在抽象类中，新增一个方法的话，继承类中可以不用作任何处理；而对于接口来说，则需要修改继承类，提供新定义的方法。
203 |
204 | 6、接口可以作用于值类型（枚举可以实现接口）和引用类型；抽象类只能作用于引用类型。
205 |
206 | 7、接口不能包含字段和已实现的方法，接口只包含方法、属性、索引器、事件的签名；抽象类可以定义字段、属性、包含有实现的方法。
207 |
208 | ### **5. 重载与覆盖的区别？**
209 |
210 | 重载：当类包含两个名称相同但签名不同(方法名相同,参数列表不相同)的方法时发生方法重载。用方法重载来提供在语义上完成相同而功能不同的方法。
211 |
212 | 覆写：在类的继承中使用，通过覆写子类方法可以改变父类虚方法的实现。
213 |
214 | 主要区别：
215 |
216 | 1、方法的覆盖是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系。 2、覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。 3、覆盖要求参数列表相同；重载要求参数列表不同。 4、覆盖关系中，调用那个方法体，是根据对象的类型来决定；重载关系，是根据调用时的实参表与形参表来选择方法体的。
217 |
218 | ### **6. 在继承中new和override相同点和区别？**
219 |
220 | 看下面的代码，有一个基类A，B1和B2都继承自A，并且使用不同的方式改变了父类方法Print（）的行为。测试代码输出什么？为什么？
221 |
222 | ```c#
223 | static void Main(string[] args)
224 | {
225 | B1 b1 = new B1(); B2 b2 = new B2();
226 | b1.Print(); b2.Print(); //输出 B1、B2
227 |
228 | A ab1 = new B1(); A ab2 = new B2();
229 | ab1.Print(); ab2.Print(); //输出 B1、A
230 | Console.ReadLine();
231 | }
232 |
233 | public class A
234 | {
235 | public virtual void Print() { Console.WriteLine("A"); }
236 | }
237 | public class B1 : A
238 | {
239 | public override void Print() { Console.WriteLine("B1"); }
240 | }
241 | public class B2 : A
242 | {
243 | public new void Print() { Console.WriteLine("B2"); }
244 | }
245 | ```
246 |
247 |
248 |
249 |
250 |
251 |
252 |
253 | ### **7.class中定义的静态字段是存储在内存中的哪个地方？为什么会说它不会被GC回收？**
254 |
255 | 随类型对象存储在内存的加载堆上，因为加载堆不受GC管理，其生命周期随AppDomain，不会被GC回收。
256 |
257 |
258 |
259 | ## 常量、字段、属性、特性与委托
260 |
261 | ### **1. const和readonly有什么区别？**
262 |
263 | const关键字用来声明编译时常量，readonly用来声明运行时常量。都可以标识一个常量，主要有以下区别： 1、初始化位置不同。const必须在声明的同时赋值；readonly即可以在声明处赋值，也可以在构造方法里赋值。 2、修饰对象不同。const即可以修饰类的字段，也可以修饰局部变量；readonly只能修饰类的字段 。 3、const是编译时常量，在编译时确定该值，且值在编译时被内联到代码中；readonly是运行时常量，在运行时确定该值。 4、const默认是静态的；而readonly如果设置成静态需要显示声明 。 5、支持的类型时不同，const只能修饰基元类型或值为null的其他引用类型；readonly可以是任何类型。
264 |
265 | ```C#
266 | public class Program
267 | {
268 | public readonly int PORT;
269 | static void Main(string[] args)
270 | {
271 | B a = new B();
272 | Console.WriteLine(a.PORT);
273 | Console.WriteLine(B.PORT2);
274 | Console.WriteLine(a.PORT3.ccc);
275 | Console.ReadLine();
276 | }
277 | }
278 |
279 | class B
280 | {
281 | //readonly即可以在声明处赋值，也可以在构造方法里赋值
282 | public readonly int PORT;
283 | //const必须在声明的同时赋值
284 | public const int PORT2 = 10;
285 |
286 | //错误public const A PORT3 = new A() const只能修饰基元类型或值为null的其他引用类型
287 |
288 | //readonly可以是任何类型
289 | public readonly A PORT3 = new A();
290 | public B()
291 | {
292 |
293 | PORT = 11;
294 | }
295 | }
296 | class A
297 | {
298 | public string ccc = "aaaa";
299 | }
300 |
301 |
302 | ```
303 |
304 |
305 |
306 | ### **2. 字段与属性有什么异同？**
307 |
308 | - 属性提供了更为强大的，灵活的功能来操作字段
309 |
310 | - 出于面向对象的封装性，字段一般不设计为Public
311 |
312 | - 属性允许在set和get中编写代码
313 |
314 | - 属性允许控制set和get的可访问性，从而提供只读或者可读写的功能 （逻辑上只写是没有意义的）
315 |
316 | - 属性可以使用override 和 new
317 |
318 | ### **3. 静态成员和非静态成员的区别？**
319 |
320 | - 静态变量使用 static 修饰符进行声明，静态成员在加类的时候就被加载（上一篇中提到过，静态字段是随类型对象存放在Load Heap上的），通过类进行访问。
321 |
322 | - 不带有static 修饰符声明的变量称做非静态变量，在对象被实例化时创建，通过对象进行访问 。
323 |
324 | - 一个类的所有实例的同一静态变量都是同一个值，同一个类的不同实例的同一非静态变量可以是不同的值 。
325 |
326 | - 静态函数的实现里不能使用非静态成员，如非静态变量、非静态函数等。
327 |
328 | ### **4. 特性是什么？如何使用？**
329 |
330 | 特性与属性是完全不相同的两个概念，只是在名称上比较相近。Attribute特性就是关联了一个目标对象的一段配置信息，本质上是一个类，其为目标元素提供关联附加信息，这段附加信息存储在dll内的元数据，它本身没什么意义。运行期以反射的方式来获取附加信息。
331 |
332 | ### **5. C#中的委托是什么？事件是不是一种委托？**
333 |
334 | 什么是委托？简单来说，委托类似于 C或 C++中的函数指针，允许将方法作为参数进行传递。
335 |
336 | - C#中的委托都继承自System.Delegate类型；
337 |
338 | - 委托类型的声明与方法签名类似，有返回值和参数；
339 |
340 | - 委托是一种可以封装命名（或匿名）方法的引用类型，把方法当做指针传递，但委托是面向对象、类型安全的；
341 |
342 | 事件可以理解为一种特殊的委托，事件内部是基于委托来实现的。
343 |
344 |
345 |
346 | ## GC与内存管理
347 |
348 | ### **1. 简述一下一个引用对象的生命周期？**
349 |
350 | - new创建对象并分配内存
351 |
352 | - 对象初始化
353 |
354 | - 对象操作、使用
355 |
356 | - 资源清理（非托管资源）
357 |
358 | - GC垃圾回收
359 |
360 | ### **2. GC进行垃圾回收时的主要流程是？**
361 |
362 | ① 标记：先假设所有对象都是垃圾，根据应用程序根Root遍历堆上的每一个引用对象，生成可达对象图，对于还在使用的对象（可达对象）进行标记（其实就是在对象同步索引块中开启一个标示位）。
363 |
364 | ② 清除：针对所有不可达对象进行清除操作，针对普通对象直接回收内存，而对于实现了终结器的对象（实现了析构函数的对象）需要单独回收处理。清除之后，内存就会变得不连续了，就是步骤3的工作了。
365 |
366 | ③ 压缩：把剩下的对象转移到一个连续的内存，因为这些对象地址变了，还需要把那些Root跟指针的地址修改为移动后的新地址。
367 |
368 | ### **6. GC在哪些情况下回进行回收工作？**
369 |
370 | - 内存不足溢出时（0代对象充满时）
371 |
372 | - Windwos报告内存不足时，CLR会强制执行垃圾回收
373 |
374 | - CLR卸载AppDomian，GC回收所有
375 |
376 | - 调用GC.Collect
377 |
378 | - 其他情况，如主机拒绝分配内存，物理内存不足，超出短期存活代的存段门限
379 |
380 | **7. using() 语法是如何确保对象资源被释放的？如果内部出现异常依然会释放资源吗？**3
381 |
382 | using() 只是一种语法形式，其本质还是try…finally的结构，可以保证Dispose始终会被执行。
383 |
384 | ### **8. 解释一下C#里的析构函数？为什么有些编程建议里不推荐使用析构函数呢？**
385 |
386 | C#里的析构函数其实就是终结器Finalize，因为长得像C++里的析构函数而已。
387 |
388 | 有些编程建议里不推荐使用析构函数要原因在于：第一是Finalize本身性能并不好；其次很多人搞不清楚Finalize的原理，可能会滥用，导致内存泄露，因此就干脆别用了
389 |
390 | ### **9. Finalize() 和 Dispose() 之间的区别？**
391 |
392 | Finalize() 和 Dispose()都是.NET中提供释放非托管资源的方式，他们的主要区别在于执行者和执行时间不同：
393 |
394 | - finalize由垃圾回收器调用；dispose由对象调用。
395 |
396 | - finalize无需担心因为没有调用finalize而使非托管资源得不到释放，而dispose必须手动调用。
397 |
398 | - finalize不能保证立即释放非托管资源，Finalizer被执行的时间是在对象不再被引用后的某个不确定的时间；而dispose一调用便释放非托管资源。
399 |
400 | - 只有class类型才能重写finalize，而结构不能；类和结构都能实现IDispose。
401 |
402 | 另外一个重点区别就是终结器会导致对象复活一次，也就说会被GC回收两次才最终完成回收工作，这也是有些人不建议开发人员使用终结器的主要原因。
403 |
404 | ### **10. Dispose和Finalize方法在何时被调用？**
405 |
406 | - Dispose一调用便释放非托管资源；
407 |
408 | - Finalize不能保证立即释放非托管资源，Finalizer被执行的时间是在对象不再被引用后的某个不确定的时间；
409 |
410 | ### **11. .NET中的托管堆中是否可能出现内存泄露的现象?**
411 |
412 | 是的，可能会。比如：
413 |
414 | - 不正确的使用静态字段，导致大量数据无法被GC释放；
415 |
416 | - 没有正确执行Dispose()，非托管资源没有得到释放；
417 |
418 | - 不正确的使用终结器Finalize()，导致无法正常释放资源；
419 |
420 | - 其他不正确的引用，导致大量托管对象无法被GC释放；
421 |
422 | ### **12. 在托管堆上创建新对象有哪几种常见方式？**
423 |
424 | - new一个对象；
425 |
426 | - 字符串赋值，如string s1=”abc”；
427 |
428 | - 值类型装箱；
429 |
430 | ## 多线程编程与线程同步
431 |
432 | ### **1. 描述线程与进程的区别？**
433 |
434 | - 一个应用程序实例是一个进程，一个进程内包含一个或多个线程，线程是进程的一部分；
435 |
436 | - 进程之间是相互独立的，他们有各自的私有内存空间和资源，进程内的线程可以共享其所属进程的所有资源；
437 |
438 | ### **2. lock为什么要锁定一个参数，可不可锁定一个值类型？这个参数有什么要求？**
439 |
440 | lock的锁对象要求为一个引用类型。它可以锁定值类型，但值类型会被装箱，每次装箱后的对象都不一样，会导致锁定无效。
441 |
442 | 对于lock锁，锁定的这个对象参数才是关键，这个参数的同步索引块指针会指向一个真正的锁（同步块），这个锁（同步块）会被复用。
443 |
444 | ### **3. 多线程和异步有什么关系和区别？**
445 |
446 | 多线程是实现异步的主要方式之一，异步并不等同于多线程。实现异步的方式还有很多，比如利用硬件的特性、使用进程或纤程等。在.NET中就有很多的异步编程支持，比如很多地方都有Begin**、End**的方法，就是一种异步编程支持，它内部有些是利用多线程，有些是利用硬件的特性来实现的异步编程。
447 |
448 | ### **4. 线程池的优点有哪些？又有哪些不足？**
449 |
450 | 优点：减小线程创建和销毁的开销，可以复用线程；也从而减少了线程上下文切换的性能损失；在GC回收时，较少的线程更有利于GC的回收效率。
451 |
452 | 缺点：线程池无法对一个线程有更多的精确的控制，如了解其运行状态等；不能设置线程的优先级；加入到线程池的任务（方法）不能有返回值；对于需要长期运行的任务就不适合线程池。
453 |
454 | ### **5. Mutex和lock有何不同？一般用哪一个作为锁使用更好？**
455 |
456 | Mutex是一个基于内核模式的互斥锁，支持锁的递归调用，而Lock是一个混合锁，一般建议使用Lock更好，因为lock的性能更好。
457 |
458 | ### **6.Thread与Task的区别**
459 |
460 | Thread 类主要用于实现线程的创建以及执行。
461 |
462 | Task 类表示以异步方式执行的单个操作。
463 |
464 | #### 1、Task 是基于 Thread 的，是比较高层级的封装，Task 最终还是需要 Thread 来执行
465 |
466 | #### 2、Task 默认使用后台线程执行，Thread 默认使用前台线程
467 |
468 | ```C#
469 | static void Main(string[] args)
470 | {
471 | Thread thread = new Thread(obj => { Thread.Sleep(3000); });
472 | thread.Start();
473 | }
474 | ```
475 |
476 |
477 |
478 | 上面代码，主程序在3秒后结束。
479 |
480 | ```C#
481 | static void Main(string[] args)
482 | {
483 | Task task = new Task(() =>
484 | {
485 | Thread,Sleep(3000);
486 | return 1;
487 | });
488 | task.Start();
489 | }
490 |
491 | ```
492 |
493 |
494 |
495 | 而这段代码，会瞬间结束。
496 |
497 | #### 3、Task 可以有返回值，Thread 没有返回值
498 |
499 | 虽然 Thread 可以通过 Start 方法参数来进行返回值处理，但十分不便。
500 |
501 | ```C#
502 | public void Start (object parameter);
503 | static void Main(string[] args)
504 | {
505 | Task task = new Task(LongRunningTask);
506 | task.Start();
507 | Console.WriteLine(task.Result);
508 | }
509 | private static int LongRunningTask()
510 | {
511 | Thread.Sleep(3000);
512 | return 1;
513 | }
514 |
515 | ```
516 |
517 |
518 |
519 | #### 4、Task 可以执行后续操作，Thread 不能执行后续操作
520 |
521 | ```C#
522 | static void Main(string[] args)
523 | {
524 | Task task = new Task(LongRunningTask);
525 | task.Start();
526 | Task childTask = task.ContinueWith(SquareOfNumber);
527 | Console.WriteLine("Sqaure of number is :"+ childTask.Result);
528 | Console.WriteLine("The number is :" + task.Result);
529 | }
530 | private static int LongRunningTask()
531 | {
532 | Thread.Sleep(3000);
533 | return 2;
534 | }
535 | private static int SquareOfNumber(Task obj)
536 | {
537 | return obj.Result * obj.Result;
538 | }
539 |
540 | ```
541 |
542 |
543 |
544 | #### 5、Task 可取消任务执行，Thread 不行
545 |
546 | ```C#
547 | static void Main(string[] args)
548 | {
549 | using (var cts = new CancellationTokenSource())
550 | {
551 | Task task = new Task(() => { LongRunningTask(cts.Token); });
552 | task.Start();
553 | Console.WriteLine("Operation Performing...");
554 | if(Console.ReadKey().Key == ConsoleKey.C)
555 | {
556 | Console.WriteLine("Cancelling..");
557 | cts.Cancel();
558 | }
559 | Console.Read();
560 | }
561 | }
562 | private static void LongRunningTask(CancellationToken token)
563 | {
564 | for (int i = 0; i < 10000000; i++)
565 | {
566 | if(token.IsCancellationRequested)
567 | {
568 | break;
569 | }
570 | else
571 | {
572 | Console.WriteLine(i);
573 | }
574 | }
575 | }
576 |
577 | ```
578 |
579 |
580 |
581 | #### 6、异常传播
582 |
583 | Thread 在父方法上获取不到异常，而 Task 可以。
584 |
585 | ## **线程间互相通信**
586 |
587 | C#线程间互相通信主要用到两个类：AutoResetEvent和ManualResetEvent.
588 |
589 | ### **一、AutoResetEvent**
590 |
591 | AutoResetEvent 允许线程通过发信号互相通信，线程通过调用 AutoResetEvent 上的 WaitOne 来等待信号。 如果 AutoResetEvent 为非终止状态，则线程会被阻止，并等待当前控制资源的线程通过调用 Set 来通知资源可用。
592 |
593 | 吃快餐的时候都会排队付款，收银员发送收款通知，客户依次付钱
594 |
595 | AutoResetEvent类一次只能通知一个等待的线程，且通知一次过后会立即将AutoResetEvent对象的状态置为false,也就是如果有两个客户都在等待收银员通知，AutoResetEvent对象的set方法只能通知到第一个客户
596 |
597 | ### **二、ManualResetEvent**
598 |
599 | 在AutoResetEvent中，如果要通知两个线程，则Set方法要被执行两次，也以快餐店的例子做了举例，但如果有一天客户1中彩票了，要请部门的10个同事吃饭，也就是说只要Set一次，所有在等待的线程都会解除等待，相当于收银员只收一次钱，10个人都可以通过收银去吃饭，这时我们就要用到ManualResetEvent类，它的用法和AutoResetEvent基本一样，区别就在于它是一量Set方法发出通知后，要再次阻塞的话就需要手动去修改，也就是调用Reset方法
600 |
601 | ### **总结**
602 |
603 | AutoResetEvent和ManualResetEvent的主要区别就在于：AutoResetEvent一次只能通知一个等待线程，通知后自动关闭； 而ManualResetEvent一次可通知很多个等待的线程，但要关闭需要调用Reset方法手动关闭
604 |
605 | ## 线程同步
606 |
607 | ### **线程同步的几种方法：**
608 |
609 | ### **1、阻塞**
610 |
611 | 当线程调用Sleep，Join，EndInvoke，线程就处于阻塞状态（Sleep使调用线程阻塞，Join、EndInvoke使另外一个线程阻塞），会立即从cpu退出。（阻塞状态的线程不消耗cpu）
612 |
613 | ### **2、加锁（lock）**
614 |
615 | 加锁使多个线程同一时间只有一个线程可以调用该方法，其他线程被阻塞。
616 |
617 | #### **同步对象的选择：**
618 |
619 | - 使用
620 |
621 | **引用类型**，值类型加锁时会装箱，产生一个新的对象。
622 |
623 | - 使用
624 |
625 | **private**修饰，使用public时易产生死锁。**（使用lock（this），lock(typeof(实例))时，该类也应该是private）**。
626 |
627 | - string不能作为锁对象。
628 |
629 | - 不能在lock中使用
630 |
631 | await关键字
632 |
633 | #### **锁是否必须是静态类型？**
634 |
635 | 如果被锁定的方法是静态的，那么这个锁必须是静态类型。这样就是在全局锁定了该方法，不管该类有多少个实例，都要排队执行。
636 |
637 | 如果被锁定的方法不是静态的，那么不能使用静态类型的锁，因为被锁定的方法是属于实例的，只要该实例调用锁定方法不产生损坏就可以，不同实例间是不需要锁的。这个锁只锁该实例的方法，而不是锁所有实例的方法.*
638 |
639 | ```C#
640 | class ThreadSafe
641 | {
642 | private static object _locker = new object();
643 |
644 | void Go()
645 | {
646 | lock (_locker)
647 | {
648 | ......//共享数据的操作 （Static Method）,使用静态锁确保所有实例排队执行
649 | }
650 | }
651 |
652 | private object _locker2=new object();
653 | void GoTo()
654 | {
655 | lock(_locker2)
656 | //共享数据的操作，非静态方法，是用非静态锁，确保同一个实例的方法调用者排队执行
657 | }
658 | }
659 | ```
660 |
661 |
662 |
663 | #### **同步对象可以兼作它lock的对象**
664 |
665 | 如：
666 |
667 | ```C#
668 | class ThreadSafe
669 | {
670 | private List _list = new List ();
671 | void Test()
672 | {
673 | lock (_list)
674 | {
675 | _list.Add ("Item 1");
676 | }
677 | }
678 | }
679 | ```
680 |
681 |
682 |
683 | ### **3、Monitors**
684 |
685 | lock其实是Monitors的简洁写法。
686 |
687 | ```C#
688 | lock (x)
689 | {
690 | DoSomething();
691 | }
692 | ```
693 |
694 |
695 |
696 | 两者其实是一样的。
697 |
698 | ```C#
699 | System.Object obj = (System.Object)x;
700 | System.Threading.Monitor.Enter(obj);
701 | try
702 | {
703 | DoSomething();
704 | }
705 | finally
706 | {
707 | System.Threading.Monitor.Exit(obj);
708 | }
709 | ```
710 |
711 |
712 |
713 | ### **4、互斥锁（Mutex）**
714 |
715 | 互斥锁是一个互斥的同步对象，同一时间有且仅有一个线程可以获取它。可以实现进程级别上线程的同步。
716 |
717 | ```C#
718 | class Program
719 | {
720 | //实例化一个互斥锁
721 | public static Mutex mutex = new Mutex();
722 |
723 | static void Main(string[] args)
724 | {
725 | for (int i = 0; i < 3; i++)
726 | {
727 | //在不同的线程中调用受互斥锁保护的方法
728 | Thread test = new Thread(MutexMethod);
729 | test.Start();
730 | }
731 | Console.Read();
732 | }
733 |
734 | public static void MutexMethod()
735 | {
736 | Console.WriteLine("{0} 请求获取互斥锁", Thread.CurrentThread.Name);
737 | mut.WaitOne();
738 | Console.WriteLine("{0} 已获取到互斥锁", Thread.CurrentThread.Name);
739 | Thread.Sleep(1000);
740 | Console.WriteLine("{0} 准备释放互斥锁", Thread.CurrentThread.Name);
741 | // 释放互斥锁
742 | mut.ReleaseMutex();
743 | Console.WriteLine("{0} 已经释放互斥锁", Thread.CurrentThread.Name);
744 | }
745 | }
746 | ```
747 |
748 |
749 |
750 | #### **互斥锁可以在不同的进程间实现线程同步**
751 |
752 | 使用互斥锁实现一个一次只能启动一个应用程序的功能。
753 |
754 | ```c#
755 | public static class SingleInstance
756 | {
757 | private static Mutex m;
758 |
759 | public static bool IsSingleInstance()
760 | {
761 | //是否需要创建一个应用
762 | Boolean isCreateNew = false;
763 | try
764 | {
765 | m = new Mutex(initiallyOwned: true, name: "SingleInstanceMutex", createdNew: out isCreateNew);
766 | }
767 | catch (Exception ex)
768 | {
769 |
770 | }
771 | return isCreateNew;
772 | }
773 | }
774 | ```
775 |
776 |
777 |
778 | #### 互斥锁的带有三个参数的构造函数
779 |
780 | 1. initiallyOwned: 如果initiallyOwned为true，互斥锁的初始状态就是被所实例化的线程所获取，否则实例化的线程处于未获取状态。
781 |
782 | 1. name:该互斥锁的名字，在操作系统中只有一个命名为name的互斥锁mutex，如果一个线程得到这个name的互斥锁，其他线程就无法得到这个互斥锁了，必须等待那个线程对这个线程释放。
783 |
784 | 1. createNew:如果指定名称的互斥体已经存在就返回false，否则返回true。
785 |
786 | ### **5、信号和句柄**
787 |
788 | lock和mutex可以实现线程同步，确保一次只有一个线程执行。但是线程间的通信就不能实现。如果线程需要相互通信的话就要使用AutoResetEvent,ManualResetEvent，通过信号来相互通信。它们都有两个状态，终止状态和非终止状态。只有处于非终止状态时，线程才可以阻塞。
789 |
790 | #### **AutoResetEvent****：**
791 |
792 | AutoResetEvent 构造函数可以传入一个bool类型的参数，false表示将AutoResetEvent对象的初始状态设置为非终止。如果为true标识终止状态，那么WaitOne方法就不会再阻塞线程了。但是因为该类会自动的将终止状态修改为非终止，所以，之后再调用WaitOne方法就会被阻塞。
793 |
794 | WaitOne 方法如果AutoResetEvent对象状态非终止，则阻塞调用该方法的线程。可以指定时间，若没有获取到信号，返回false
795 |
796 | set 方法释放被阻塞的线程。但是一次只可以释放一个被阻塞的线程。
797 |
798 | ```C#
799 | class ThreadSafe
800 | {
801 | static AutoResetEvent autoEvent;
802 |
803 | static void Main()
804 | {
805 | //使AutoResetEvent处于非终止状态
806 | autoEvent = new AutoResetEvent(false);
807 |
808 | Console.WriteLine("主线程运行...");
809 | Thread t = new Thread(DoWork);
810 | t.Start();
811 |
812 | Console.WriteLine("主线程sleep 1秒...");
813 | Thread.Sleep(1000);
814 |
815 | Console.WriteLine("主线程释放信号...");
816 | autoEvent.Set();
817 | }
818 |
819 | static void DoWork()
820 | {
821 | Console.WriteLine(" t线程运行DoWork方法，阻塞自己等待main线程信号...");
822 | autoEvent.WaitOne();
823 | Console.WriteLine(" t线程DoWork方法获取到main线程信号，继续执行...");
824 | }
825 |
826 | }
827 |
828 | //输出
829 | //主线程运行...
830 | //主线程sleep 1秒...
831 | // t线程运行DoWork方法，阻塞自己等待main线程信号...
832 | //主线程释放信号...
833 | // t线程DoWork方法获取到main线程信号，继续执行...
834 | ```
835 |
836 |
837 |
838 | #### **ManualResetEvent**
839 |
840 | ManualResetEvent和AutoResetEvent用法类似。
841 |
842 | AutoResetEvent在调用了Set方法后，会自动的将信号由释放（终止）改为阻塞（非终止），一次只有一个线程会得到释放信号。而ManualResetEvent在调用Set方法后不会自动的将信号由释放（终止）改为阻塞（非终止），而是一直保持释放信号，使得一次有多个被阻塞线程运行，只能手动的调用Reset方法，将信号由释放（终止）改为阻塞（非终止）,之后的再调用Wait.One方法的线程才会被再次阻塞。
843 |
844 | ```C#
845 | public class ThreadSafe
846 | {
847 | //创建一个处于非终止状态的ManualResetEvent
848 | private static ManualResetEvent mre = new ManualResetEvent(false);
849 |
850 | static void Main()
851 | {
852 | for(int i = 0; i <= 2; i++)
853 | {
854 | Thread t = new Thread(ThreadProc);
855 | t.Name = "Thread_" + i;
856 | t.Start();
857 | }
858 |
859 | Thread.Sleep(500);
860 | Console.WriteLine("\n新线程的方法已经启动，且被阻塞，调用Set释放阻塞线程");
861 |
862 | mre.Set();
863 |
864 | Thread.Sleep(500);
865 | Console.WriteLine("\n当ManualResetEvent处于终止状态时，调用由Wait.One方法的多线程，不会被阻塞。");
866 |
867 | for(int i = 3; i <= 4; i++)
868 | {
869 | Thread t = new Thread(ThreadProc);
870 | t.Name = "Thread_" + i;
871 | t.Start();
872 | }
873 |
874 | Thread.Sleep(500);
875 | Console.WriteLine("\n调用Reset方法，ManualResetEvent处于非阻塞状态，此时调用Wait.One方法的线程再次被阻塞");
876 |
877 |
878 | mre.Reset();
879 |
880 | Thread t5 = new Thread(ThreadProc);
881 | t5.Name = "Thread_5";
882 | t5.Start();
883 |
884 | Thread.Sleep(500);
885 | Console.WriteLine("\n调用Set方法，释放阻塞线程");
886 |
887 | mre.Set();
888 | }
889 |
890 |
891 | private static void ThreadProc()
892 | {
893 | string name = Thread.CurrentThread.Name;
894 |
895 | Console.WriteLine(name + " 运行并调用WaitOne()");
896 |
897 | mre.WaitOne();
898 |
899 | Console.WriteLine(name + " 结束");
900 | }
901 | }
902 |
903 |
904 | //Thread_2 运行并调用WaitOne()
905 | //Thread_1 运行并调用WaitOne()
906 | //Thread_0 运行并调用WaitOne()
907 |
908 | //新线程的方法已经启动，且被阻塞，调用Set释放阻塞线程
909 |
910 | //Thread_2 结束
911 | //Thread_1 结束
912 | //Thread_0 结束
913 |
914 | //当ManualResetEvent处于终止状态时，调用由Wait.One方法的多线程，不会被阻塞。
915 |
916 | //Thread_3 运行并调用WaitOne()
917 | //Thread_4 运行并调用WaitOne()
918 |
919 | //Thread_4 结束
920 | //Thread_3 结束
921 |
922 | ///调用Reset方法，ManualResetEvent处于非阻塞状态，此时调用Wait.One方法的线程再次被阻塞
923 |
924 | //Thread_5 运行并调用WaitOne()
925 | //调用Set方法，释放阻塞线程
926 | //Thread_5 结束
927 | ```
928 |
929 |
930 |
931 | ### **6、Interlocked**
932 |
933 | 如果一个变量被多个线程修改，读取。可以用Interlocked。
934 |
935 | 计算机上不能保证对一个数据的增删是原子性的，因为对数据的操作也是分步骤的：
936 |
937 | 1. 将实例变量中的值加载到寄存器中。
938 |
939 | 1. 增加或减少该值。
940 |
941 | 1. 在实例变量中存储该值。
942 |
943 | Interlocked为多线程共享的变量提供原子操作。Interlocked提供了需要原子操作的方法：
944 |
945 | - public static int Add (ref int location1, int value); 两个参数相加，且把结果和赋值该第一个参数。
946 |
947 | - public static int Increment (ref int location); 自增。
948 |
949 | - public static int CompareExchange (ref int location1, int value, int comparand);
950 |
951 | location1 和comparand比较，被value替换. value 如果第一个参数和第三个参数相等，那么就把value赋值给第一个参数。 comparand 和第一个参数对比。
952 |
953 | ------
954 |
955 | ### **7、ReaderWriterLock**
956 |
957 | 如果要确保一个资源或数据在被访问之前是最新的。那么就可以使用ReaderWriterLock.该锁确保在对资源获取赋值或更新时，只有它自己可以访问这些资源，其他线程都不可以访问。即排它锁。但用改锁读取这些数据时，不能实现排它锁。
958 |
959 | lock允许同一时间只有一个线程执行。而ReaderWriterLock允许同一时间有多个线程可以执行**读操作**，或者只有一个有排它锁的线程执行**写操作**。
960 |
961 | ```C#
962 | class Program
963 | {
964 | // 创建一个对象
965 | public static ReaderWriterLock readerwritelock = new ReaderWriterLock();
966 | static void Main(string[] args)
967 | {
968 | //创建一个线程读取数据
969 | Thread t1 = new Thread(Write);
970 | // t1.Start(1);
971 | Thread t2 = new Thread(Write);
972 | //t2.Start(2);
973 | // 创建10个线程读取数据
974 | for (int i = 3; i < 6; i++)
975 | {
976 | Thread t = new Thread(Read);
977 | // t.Start(i);
978 | }
979 |
980 | Console.Read();
981 |
982 | }
983 |
984 | // 写入方法
985 | public static void Write(object i)
986 | {
987 | // 获取写入锁，20毫秒超时。
988 | Console.WriteLine("线程：" + i + "准备写...");
989 | readerwritelock.AcquireWriterLock(Timeout.Infinite);
990 | Console.WriteLine("线程：" + i + " 写操作" + DateTime.Now);
991 | // 释放写入锁
992 | Console.WriteLine("线程：" + i + "写结束...");
993 | Thread.Sleep(1000);
994 | readerwritelock.ReleaseWriterLock();
995 |
996 | }
997 |
998 | // 读取方法
999 | public static void Read(object i)
1000 | {
1001 | Console.WriteLine("线程：" + i + "准备读...");
1002 |
1003 | // 获取读取锁，20毫秒超时
1004 | readerwritelock.AcquireReaderLock(Timeout.Infinite);
1005 | Console.WriteLine("线程：" + i + " 读操作" + DateTime.Now);
1006 | // 释放读取锁
1007 | Console.WriteLine("线程：" + i + "读结束...");
1008 | Thread.Sleep(1000);
1009 |
1010 | readerwritelock.ReleaseReaderLock();
1011 |
1012 | }
1013 | }
1014 | //分别屏蔽writer和reader方法。可以更清晰的看到 writer被阻塞了。而reader没有被阻塞。
1015 |
1016 | //屏蔽reader方法
1017 | //线程：1准备写...
1018 | //线程：1 写操作2017/7/5 17:50:01
1019 | //线程：1写结束...
1020 | //线程：2准备写...
1021 | //线程：2 写操作2017/7/5 17:50:02
1022 | //线程：2写结束...
1023 |
1024 | //屏蔽writer方法
1025 | //线程：3准备读...
1026 | //线程：5准备读...
1027 | //线程：4准备读...
1028 | //线程：5 读操作2017/7/5 17:50:54
1029 | //线程：5读结束...
1030 | //线程：3 读操作2017/7/5 17:50:54
1031 | //线程：3读结束...
1032 | //线程：4 读操作2017/7/5 17:50:54
1033 | //线程：4读结束...
1034 | ```
1035 |
1036 |
1037 |
1038 | ## WPF
1039 |
1040 | ### **1.WPF由哪两部分组成？**
1041 |
1042 | wpf 由两个主要部分 组成：引擎和编程框架。
1043 |
1044 | 1 引擎。wpf引擎是基于窗体的应用程序 图形 视频 音频和文档提供了一个单一的运行时库。重要的是WPF基于矢量的呈现引擎使应用程序可以灵活地利用高DPI监视器，支持图形的硬件加速。
1045 |
1046 | 2 框架。WPF框架为媒体 用户界面设计和文档提供大量的解决方案。wpf的设计考虑了可扩展性，使开发人员可以完全在WPF引擎的基础上创建自己的控件，也可以通过对现有WPF控件进行再分类来创建自己的控件。
1047 |
1048 | ### **2.什么是WPF？**
1049 |
1050 | WPF英文全称是Windows Presentation Foundation，中文为Windows表现层基础。是微软最初在.NET Framework3.5平台推出的一个图形平台。
1051 |
1052 | ### **3. Silverlight 和 WPF的异同？**
1053 |
1054 | 它们的运行方式是不同的：
1055 |
1056 | #### 1 silverlight是基于浏览器插件的，在浏览器中运行。
1057 |
1058 | #### 2 WPF可以编写Web程序或者桌面应用程序，可以直接编译为独立运行的exe文件。
1059 |
1060 | 实现功能是不同的：
1061 |
1062 | #### 1 WPF支持直接在XAML中绑定触发来触发动画，而silverlight就只能通过托管代码或者javascript来进行。
1063 |
1064 | #### 2 WPF直接支持3D效果和3D镜头变换，但是silverlight就不支持。
1065 |
1066 | 它们也有相似的地方：
1067 |
1068 | silverlight 原名WPF/E 就是WPF Everywhere 是WPF的一个子集。因此它们在很多语法实现上非常类似。
1069 |
1070 | **4.如何理解WPF体系结构？**
1071 |
1072 | WPF使用多层架构，类似于三层结构，最顶层部分为托管代码API，此层用于为开发人员编写WPF应用程序提供较高层次的服务，基于C#托管代码编写。转换.NET代码到DirectX的工作由中间层milcore.dll实现。
1073 |
1074 | 中间层milcore是用非托管代码实现，因为它需要与DirectX紧密集成，对性能敏感，就是消耗的资源比较多，对性能影响较大。
1075 |
1076 | ### **5. 在WPF中Binding的作用及实现语法？**
1077 |
1078 | 典型的Binding具有四个重要组成部分：Binding目标对象（binding target object） 目标对象属性（target property） Binding数据源（binding source） Path(用于指明要从数据源中取得的值，就是我们通常写的属性名称）。
1079 |
1080 | ### **6.什么是XML扩展XAML?有何优点？**
1081 |
1082 | 1 XAML是eXtensible Application Markup Language的英文缩写，相应于中文称为可扩展应用程序标记语言，它是微软公司为构建应用程序用户界面而创建的一种新的描述性语言。
1083 |
1084 | 2 XAML是XML语言的一个衍生物，它的语法与XML语言完全一致，它的功能就是专门用来设计和实现程序的UI。
1085 |
1086 | 3 XAML一个很大的优点就是由于WPF支持WEB开发，那么WEB开发和桌面开发的转换是很简单，修改的地方很短，同时UI与逻辑完全分离，所以逻辑代码也几乎不用改动。
1087 |
1088 | ### **7. 解释什么是依赖属性，它和以前的属性有什么不同？为什么在WPF会使用它？**
1089 |
1090 | 1 Windows Presentation Foundation (WPF) 提供了一组服务，这些服务可用于扩展公共语言运行时 (CLR) 属性的功能，这些服务通常统称为 WPF 属性系统。由 WPF 属性系统支持的属性称为依赖项属性。
1091 |
1092 | 2 它和以往属性的不同之处有
1093 |
1094 | (1)依赖属性是一种特定类型的属性。这种属性的特殊之处在于，其属性值受到 Windows 运行时中专用属性系统的跟踪和影响。
1095 |
1096 | (2)依赖属性的用途是提供一种系统的方式，用来基于其他输入（在应用运行时其内部出现的其他属性、事件和状态）计算属性的值。
1097 |
1098 | (3)依赖属性代表或支持编程模型的某种特定功能，用于定义 Windows 运行时应用，这种模型使用 XAML 编写 UI，使用 C#、Microsoft Visual Basic 或 Visual C++ 组件扩展 (C++/CX) 编写代码。
1099 |
1100 | 一般的属性没有这么复杂。
1101 |
1102 | 3 WPF使用它是有不少优点的
1103 |
1104 | （1）优化了属性的存储，直接减少了不必要的内存使用。
1105 |
1106 | （2）有属性变化通知 限制 验证等。
1107 |
1108 | （3）可以储存多个值，配合Expression及Animation等，打造出更灵活的使用方法。
1109 |
1110 | ### **8. WPF中什么是样式？**
1111 |
1112 | 首先明白WPF中样式属于资源中重要的一种。
1113 |
1114 | 同时样式也是属性值的集合，能被应用到一个合适的元素中，或者说能将一组属性应用到多个元素。
1115 |
1116 | WPF中样式可以设置任何依赖属性。
1117 |
1118 | WPF中样式也支持触发器，通过属性的改变，触发一组活动，包括改变某个控件的样式。
1119 |
1120 | WPF中元素只能使用一个样式。
1121 |
1122 | 样式有继承的特性，样式可以继承样式。
1123 |
1124 | ### **9. WPF中什么是模板 ？**
1125 |
1126 | WPF中模板是用于定义或重定义控件结构，或者说对象的外观。
1127 |
1128 | WPF中模板有两类，一个是控件模板（ControlTemplate) 另一个是数据模板（DataTemplate），它们都派生自FrameworkTemplate抽象类。
1129 |
1130 | 总共有三大模板 ControlTemplate，ItemsPanelTemplate，DataTemplate。
1131 |
1132 | 1 ControlTemplate 主要用途是更改控件的外观。它有两个重要属性：VisualTree（视觉树）内容属性和Triggers触发器，对于触发器可以不用过多考虑，触发器可有可无。VisualTree就是呈现我们所画的控件。Triggers可以对我们的视觉树上的元素进行一些变化。
1133 |
1134 | 2 ItemsPanelTemplate 是个特殊的空间模板，主要用来标明多条目控件如何显示它所包含的多项数据。也可以说是指定用于项的额布局的面板。多用于多个内容控件的目标。多为Panel属性或者Panel结尾的属性。
1135 |
1136 | 3 DataTemplate 主要用于数据的呈现。也被称为显示绑定数据对象的模板。
1137 |
1138 | [WPF](https://so.csdn.net/so/search?q=WPF&spm=1001.2101.3001.7020)中有控件模板和数据模板，控件模板可以让我们自定义控件的外观，而数据模板定义了数据的显示方式，也就是数据对象的可视结构，但是这里有一个问题需要考虑，数据是如何显示出来的？虽然数据模板定义了数据的可视结构，但是我们清楚的知道，只有控件才是可视的，数据一般是被控件承载，这里需要另外的一个对象ContentPresenter。
1139 |
1140 | ### **10. 绑定（Binding ）的基础用法**
1141 |
1142 | WPF 里分三种：Binding,PriorityBinding,MultiBinding,这三种Binding的基类都是BindingBase，而BindingBase又继承于MarkupExtension。
1143 |
1144 | 常见的使用Binding方法是：
1145 |
1146 | 1 针对于继承于FrameworkElement控件。 SetBinding(DependencyProperty dp,String path),SetBinding(DependencyProperty dp,BindingBase binding),其中FrameworkElement中SetBinding只对DependencyProperty有效。
1147 |
1148 | 2 另一种是 BindingOperations.SetBinding(currentFolder,TextBlock.TextProperty,binding);
1149 |
1150 | BindingOperations.SetBinding的原型是
1151 |
1152 | public static BindingExpressionBase SetBinding(DependencyObject target,DependencyProperty dp,BindingBase binding)
1153 |
1154 | 3 清除Binding:
1155 |
1156 | BindingOperations.ClearBinding(currentFolder,TextBlock.TextProperty);//删除currentFolder上的TextBlock.TextProperty绑定
1157 |
1158 | BindingOperations.ClearAllBindings(currentFolder);//删除currentFolder上的所有绑定。
1159 |
1160 | 直接对Dependency Property赋值也可以解除binding，不过只对单向binding有效。
1161 |
1162 | ### **11. 解释这几个类的作用及关系: Visual, UIElement, FrameworkElement, Control 。**
1163 |
1164 | 它们四个的关系：从System.Windows.Controls命名空间中看，依次的继承关系是：
1165 |
1166 | Visual继承UIElement,UIElement继承FrameworkElement,FrameworkElement继承Control。
1167 |
1168 | 1 Visual主要作用是为WPF提供2D呈现支持，主要包括输出显示，坐标转换，区域剪切等。
1169 |
1170 | 2 UIElement的主要作用是构建WPF元素和基本呈现特征的基类。例如其中定义很多与输入和焦点有关的特性，例如键盘事件，鼠标，还有一些与WPF事件模型有关的API。
1171 |
1172 | 3 FrameworkElement的主要作用是为定义的WPF元素添加一些功能。例如，布局定义 逻辑树 对象生命周期事件 支持数据绑定和动态资源引用 支持样式和动画。
1173 |
1174 | 4 Control的主要作用是为自定义应用程序控件提供基础。因为它是创建自定义应用程序控件的基类,作用就是可以重写Control类所提供的属性，方法，事件等，为自定义控件添加自定义逻辑。构建WPF应用程序页面的Window类也派生自它。
1175 |
1176 | ### **12. 视觉树 VS 逻辑树?**
1177 |
1178 | 1 逻辑树是视觉树的子集，也就是视觉树基本上是逻辑树的一种扩展。
1179 |
1180 | 2 WPF通过逻辑树来解决依赖项属性继承和资源的问题，使用视觉树来处理渲染，事件路由，资源定位等问题。
1181 |
1182 | 3 逻辑树可以认为是XAML所见的，而视觉树包含了XAML元素内部的结构。
1183 |
1184 | 4 逻辑树的查找可以通过LogicalTreeHelper辅助类，视觉树的查找可以通过VisualTreeHelper辅助类，其中需要注意的是对ContentElement元素的查找，无法直接通过VisualTreeHelper进行查找，ContentElement元素并不继承Visual，而ContentElement元素的使用时需要一个ContentElement载体FrameworkContentElement。
1185 |
1186 | 六 属性变更通知(INotifyPropertyChanged 和 ObservableCollection)
1187 |
1188 | 1 INotifyPropertyChanged向客户端发出某一属性值更改的通知。
1189 |
1190 | 2 ObservableCollection类，它是实现 INotifyCollectionChanged 接口的数据集合的内置实现。表示一个动态数据集合，在添加项、移除项或刷新整个列表时，此集合将提供通知
1191 |
1192 | ### **13. 解释一下ResourceDictionary ？**
1193 |
1194 | 提供包含元素和 WPF 应用程序的其他元素使用的 WPF 资源的一个哈希表/字典实现。
1195 |
1196 | 有利于项目中资源共享。
1197 |
1198 | ### **14. 路由事件的哪三种方式/策略（冒泡 直接 隧道）？**
1199 |
1200 | WPF中的路由事件是沿着VisualTree传递的，作用是用来调用应用程序的元素树上的各种监听器上的处理程序。
1201 |
1202 | （1）冒泡，这种事件处理方式是从源元素向上级流过去，直到到达根节点即顶层节点，一般为最外层的控件。
1203 |
1204 | （2）直接，这种处理方式是在源上处理，主要用在源元素上处理。通常setter和trigger中有所体现，我个人认为VisualState可视状态可能也是直接事件处理，也是依赖属性的状态改变。和Trigger有一定的重复，但是VisualState是通过生硬的动画间接实现依赖属性的改变。
1205 |
1206 | （3）隧道，又称作Preview事件，和冒泡事件处理方式相反的。元素树的根位置调用事件处理程序，依次向下直到源元素位置。
1207 |
1208 | 隧道事件和冒泡事件一般成对出现。同一事件，执行时首先是隧道事件，然后是冒泡事件。
1209 |
1210 | ### **15. 解释Routed Events(路由事件) 与 Commands(命令)？**
1211 |
1212 | Event 和 Command 是程序内部通信基础，Routed Events 能够发起多重控件，并且能有序和用户沟通。
1213 |
1214 | Commands是.NET Framework 提供的核心构架，来激活和去除高级别任务。
1215 |
1216 | 由此衍生的Animation是events的更进一步。让你能够以友好互动的方式使用Event架构，来使用多重控件。
1217 |
1218 | ### **16.模板**
1219 |
1220 | WPF模板有三种：
1221 |
1222 | ControlTemplate、
1223 |
1224 | DataTemplate、
1225 |
1226 | ItemsPanelTemplate，
1227 |
1228 | 它们都继承自FrameworkTemplate抽象类。在这个抽象类中有一个FrameworkElementFactory类型的VisualTree变量，通过该变量可以设置或者获取模板的根节点，包含了你想要的外观元素树。
1229 |
1230 | （1） 控件模板。控件模板可以将自定义模板应用到某一特定类型的所有控件，或是控件的某一实例。决定控件外观的是ControlTemplate，它决定了控件“长成什么样子”，因此控件模板由ControlTemplate类表示。控件模板实际在资源集合或资源字典中定义。例子详见：[通过设计ControlTemplate，制作圆角文本框与圆角按钮](https://www.cnblogs.com/zhouhb/p/3284780.html)（http://www.cnblogs.com/zhouhb/p/3284780.html）。（2） 数据模板。在WPF中，决定数据外观的是DataTemplate，即DataTemplate是数据内容的表现形式，一条数据显示成什么样子，是简单的文本还是直观的图形，就是由DataTemplate决定的。例子详见：[DataTemplate应用](https://www.cnblogs.com/zhouhb/p/3284827.html)（http://www.cnblogs.com/zhouhb/p/3284827.html）。
1231 |
1232 | （3）ItemsPanelTemplate模板。ItemsPanelTemplate 指定用于项的布局的面板。如下面的例子通过设置ListBox的ItemsPanelTemplate，使得每一项从左至右按顺序显示。
1233 |
1234 | #### **1、ControlTemplate**
1235 |
1236 | ControlTemplate:控件模板主要有两个重要属性：VisualTree内容属性和Triggers触发器。所谓VisualTree(视觉树),就是呈现我们所画的控件。Triggers可以对我们的视觉树上的元素进行一些变化。一般用于单内容控件。
1237 |
1238 | #### **2、ItemsPanelTemplate**
1239 |
1240 | ItemsPanelTemplate在MSDN的解释是：ItemsPanelTemplate 指定用于项的布局的面板。 [GroupStyle](http://msdn.microsoft.com/zh-cn/library/system.windows.controls.groupstyle.aspx) 具有一个类型为 ItemsPanelTemplate 的 [Panel](http://msdn.microsoft.com/zh-cn/library/system.windows.controls.groupstyle.panel.aspx) 属性。 [ItemsControl](http://msdn.microsoft.com/zh-cn/library/system.windows.controls.itemscontrol.aspx) 类型具有一个类型为ItemsPanelTemplate 的 [ItemsPanel](http://msdn.microsoft.com/zh-cn/library/system.windows.controls.itemscontrol.itemspanel.aspx) 属性。
1241 |
1242 | 我们先讲ItemTemplate。它一般用在多个内容控件的模板。比如ListBox。
1243 |
1244 | #### **3、DataTemplate和HierarchicalDataTemplate**
1245 |
1246 | DataTemplate就是显示绑定数据对象的模板。
1247 |
1248 | WPF中的数据模板(DataTemplate) 在WPF中我们可以为自己的数据定制显示方式，也就是说虽然某数据数据是一定 的，但我们可以做到让它的表现方式多种多样
1249 |
1250 |
1251 |
1252 | HierarchicalDataTemplate继承于DataTemplate，它专门对TreeViewItem 或 MenuItem的一些数据对象的绑定。
1253 |
1254 | ### **17.触发器**
1255 |
1256 | WPF中的触发器，是对WPF事件的一种封装，WPF中的触发器，有多种方式，总结起来可分为：
1257 |
1258 | - 控件触发（FrameworkElement.Triggers集合）
1259 | - 样式触发（Styles.Triggers集合）
1260 | - 控件模板触发（ControlTemplate.Triggers集合）
1261 | - 数据模板触发（DataTemplate.Triggers集合）
1262 |
1263 | 触发器种类
1264 |
1265 | System.Windows.DataTrigger 数据触发器
1266 |
1267 | System.Windows.EventTrigger 事件触发器
1268 |
1269 | System.Windows.MultiDataTrigger 多数据触发器
1270 |
1271 | System.Windows.MultiTrigger 多属性触发器
1272 |
1273 | System.Windows. Trigger 属性触发器
1274 |
1275 | #### **1、属性触发器 Trigger**
1276 |
1277 | 顾名思义，属性触发器是由属性的改变而引起的，所以属性触发器有几个关键属性：
1278 |
1279 | Property：获取或设置返回的值进行比较的属性 [Value](https://msdn.microsoft.com/zh-cn/library/system.windows.trigger.value.aspx) 触发器的属性。 比较是引用相等性检查。（只有依赖属性才有用）
1280 |
1281 | Value：获取或设置要与该元素的属性值进行比较的值。 比较是引用相等性检查
1282 |
1283 | Setter：获取一套 [Setter](https://msdn.microsoft.com/zh-cn/library/system.windows.setter.aspx) 对象，描述要应用当满足指定的条件的属性值。
1284 |
1285 | Setter： 属性是一个SetterBaseCollection 的集合。
1286 |
1287 | #### **Setter类：**
1288 |
1289 | Property：获取或设置的属性与其 Value 将应用。**（只有依赖属性才有用）**
1290 |
1291 | Value：获取或设置要应用于指定此属性的值 Setter。
1292 |
1293 | 以下代码，指定了属性触发器的使用，由于属性触发一般应用与样式定义中。
1294 |
1295 | 
1296 |
1297 | ``` xaml
1298 |
1313 | ```
1314 |
1315 |
1316 |
1317 | #### **2、多属性触发器MultiTrigger**
1318 |
1319 | 多属性触发器，是之一个或者多个样式发生变化时候，才会触发的触发器，其有一个重要属性Condition，用于统计条件，MultiTrigger.Conditions是一个Condition的集合，做一个简单案例，就能说明：
1320 |
1321 | ```xaml
1322 |
1335 | ```
1336 |
1337 |
1338 | #### **3、事件触发器EventTrigger**
1339 |
1340 | 事件触发器，是由控件的操作触发的信息，EventTrigger 属性里面，几个关键属性是：
1341 |
1342 | RoutedEvent：获取或设置将激活该触发器的 RoutedEvent。
1343 |
1344 | Actions：获取事件发生时要应用的操作的集合。
1345 |
1346 | 主要用于指定路由事件和Actions,那么Actions是什么呢？其定义如下：
1347 |
1348 | ```C#
1349 | public TriggerActionCollection Actions { get; }
1350 | ```
1351 |
1352 |
1353 |
1354 | 它是一个TriggerAction的集合
1355 |
1356 | **System.Windows.Interactivity.TriggerAction**
1357 |
1358 | [Microsoft.Expression.Interactivity.Core.CallMethodAction](https://msdn.microsoft.com/zh-cn/library/microsoft.expression.interactivity.core.callmethodaction(v=expression.40).aspx)
1359 |
1360 | [Microsoft.Expression.Interactivity.Media.PlaySoundAction](https://msdn.microsoft.com/zh-cn/library/microsoft.expression.interactivity.media.playsoundaction(v=expression.40).aspx)
1361 |
1362 | [Microsoft.Expression.Interactivity.Media.StoryboardAction](https://msdn.microsoft.com/zh-cn/library/microsoft.expression.interactivity.media.storyboardaction(v=expression.40).aspx)
1363 |
1364 | [System.Windows.Interactivity.InvokeCommandAction](https://msdn.microsoft.com/zh-cn/library/system.windows.interactivity.invokecommandaction(v=expression.40).aspx)
1365 |
1366 | 所以事件触发器，只能调用CallMethodAction，PlaySoundAction，StoryboardAction，InvokeCommandAction，所以事件触发器一般应用与动画中，我们以StoryboardAction为例，我们知道StoryboardAction是Storyboard的一个封装，其主要是封装了动作BeginStoryboard，该动作相当于调用BeginAnimation方法，我们案例如下：
1367 |
1368 | ```xaml
1369 |
1384 | ```
1385 |
1386 |
1387 |
1388 | #### **4、数据触发DataTrigger**
1389 |
1390 | 数据触发器，是使用在数据改变的触发，DataTrigger也有两个重要的属性
1391 |
1392 | Binding：获取或设置产生数据对象的属性值的绑定。
1393 |
1394 | Value：获取或设置要与此数据对象的属性值进行比较的值。
1395 |
1396 | 案例代码如下：
1397 |
1398 | ```xaml
1399 |
1408 | ```
1409 |
1410 | #### 5、多数据触发器MultiDataTrigger
1411 |
1412 | 多数据触发器，是对数据触发器的扩展，需要同时满足多个数据改变的情况下才执行。
1413 |
1414 | 我们对5种触发器，在4个触发环境中，我进行了简单的分类，虽然有些触发器在有的触发方式中可以使用，但并不代表一定有作用，这个在使用中根据情况进行区分，分类如下：
1415 |
1416 | | 触发方式 | 可使用的触发器 | 说明 |
1417 | | ------------ | ---------------------------------------------------------- | ------------------------ |
1418 | | 控件触发 | 必须使用EventTrigger | 用于调整界面，实现动画等 |
1419 | | 样式触发 | TriggerEventTriggerMultiTriggerDataTriggerMultiDataTrigger | 可使用所有触发器 |
1420 | | 控件模板触发 | TriggerEventTriggerMultiTriggerDataTriggerMultiDataTrigger | 可使用所有触发器 |
1421 | | 数据模板触发 | TriggerEventTriggerMultiTriggerDataTriggerMultiDataTrigger | 可使用所有触发器 |
1422 |
--------------------------------------------------------------------------------