.NET 庠幀庐嵐 C# 庠嵐崰嵐庠巠 巐嶐庀嶀巠庀幀嵐

© 庐庀嶐幰 庀嶐巠崀 1

巐嶐庀嶀巠庀幀嵐 庠嵐崰嵐庠巠 崐-C#巀 庠嶰嶐嶐庐 庠嵐嶐嵀巀 庠崐嶐嶐嵰 嵀嶐幠幰帀嵐幀 巀嶰 -class巐嶐嶐嵐帐巠 , 庠嵐嶐幠幰帀嵐幀巀 崀嵐庀幰巀 崠嵐嵀帀 巰嶰巀C#

庠嵐崰嵐庠巠) 巀庐 嵀嶐幠幰帀嵐幀 嵀帀嶐嵀 嵀崰嵐庠巠class – 嵀帀嵐嶰巠庐 嵀巠 member function崐 -C++.( 嵀崰嵐庠巠嵀 庠崀 庀崐嶰 嵐帀庐崠幀 嵀庐帠巠巀Main 庠嵐崰嵐庠巠巀 嵀崀嶐庀幰 巐嶐帠幠崐巠 嶠嶐崀 嵐帀嶐崀庀 巐崠嵐 ) 嵐帀帠幠嶐崐

嵐庠巠巀 嵀崀嶐庀幰 巀庐巠巀 嵀崰Console.WriteLine(string)( , 巐嶐庀嶐崰崠巠 嶠嶐崀 庠帠嶰 庠嵐崀庀巀 嵐帀巀 庀崀庐帀嵀庐崰嵰 嵀崰嵐庠巠.

嵀幀嶐庐嵰 庠巠庀)Access Modifier(

庠嵐崀崐嵀 庠嵐嶐嵐庀庐幀崀嵀 巰嶐崐巠 嵀幀嶐庐嵰 庠巠庀 庠帠崐幰帀 嵀崰嵐庠巠 巀嶰巀:

public 巐嵐幰巠 巀嶰巠 嵀庐嶐崠帀 嵀崰嵐庠巠嵀 ,巠 巀巀嵐嶰-Assemblies巐嶐庀嵰崀 .

internal

崐 嵀庐嶐崠帀 嵀崰嵐庠巠嵀-Assembly嵀庀崰崠嵐嵀 崀嶐嵀 嵐崐庐 崰崐巀崐 .

private 崐 嵀庐嶐崠帀 嵀崰嵐庠巠嵀-class崰崐巀崐 嵀庀崰崠嵐嵀 崀嶐嵀 嵐崐庐 .

嵀 嵀幀嶐庐嵰嵀 庠巠庀 嶐嵀嵐嵠-default-崐 嵀崰嵐庠巠巀 庠嶐-C#.

protected 崐 嵀庐嶐崠帀 嵀崰嵐庠巠嵀-class嵐嶐庀嵠崠帀崐嵐 嵀庀崰崠嵐嵀 崀嶐嵀 嵐崐庐 ,嵐庀崰崠嵐嵀庐 庠嵐庐庀嵐帀 庠嵐幰巀嵰巠 巀巀嵐嶰

崐-Assembly 庀嵰崀 )嶠庐巠嵀崐 庀崐崰帀 嵀庐庀嵐嵀 巀帠.(

protected internal 崐 嵀庐嶐崠帀 嵀崰嵐庠巠嵀-class嵐嶐庀嵠崠帀崐嵐 嵀庀崰崠嵐嵀 崀嶐嵀 嵐崐庐 ,嵐庀崰崠嵐嵀庐 庠嵐庐庀嵐帀 庠嵐幰巀嵰巠 巀巀嵐嶰

崐-Assembly庀嵰崀 ,帰帐嵐帀崐嵐 ,崐 巐嵐幰巠 巀嶰崐-Assembly嵀庀崰崠嵐嵀 嵀崰嵐庠巠嵀 嵐崐庐 . )崐巀 巐嶐庐 : 嵀幀嶐庐嵰嵀 庠巠庀protected internal 嵀幀嶐庐嵰嵀 庠巠庀 庠崀 嵀崐嶐嵰庀巠 protected

嵀庠嵐崀 庠巠幠巠幠巠 崀巀嵐–崐 巰庠嶐帀 崀巀 -C# 嵀幀嶐庐嵰嵀 庠巠庀 庠崀 巐幠巠幠巀 protected嶐崠巀 嶠嵐庠巠 嵀庐嵀-Assembly崰崐巀崐 .(

庠嵐崰嵐庠巠instance庠嵐嶐嶀嶀帐 庠嵐崰嵐庠巠 庠巠嵐帠巀

庠崰嵐庠巠instance) 庀巠嵐巀嶰–庠嶐嶀嶀帐 崀巀 嵀崰嵐庠巠 ( 巰嶰巀嵐 嶀幰嶐嶐崐嵐崀 巀帠 庠巀帠幀嵐巠庐 嵀崰嵐庠巠 嵀帀嶐嵀 嶀幰嶐嶐崐嵐崀嵀 巀庐 庠嵐崰庐嵀 巀嶰巀 庠庐崠巀 嵀巀嵐嶰嶐)崐-C++ 嵀庠嵐崀 嵐帀嶐帀嶐嶰 – member function.(

嶀嵐庐幀 庀巠崀帀庐嶰"嵀崰嵐庠巠 " 庠崰嵐庠巠巀 巰嵐嵐嶰庠帀instance. 巠 巀帠 庠巀帠幀嵐巠庐 嵀崰嵐庠巠 嵀帀嶐嵀 庠嶐嶀嶀帐 嵀崰嵐庠class 巐嶐嶐嶀嶀帐 庠嵐崰庐巀 幰庀 庠庐崠巀 嵀巀嵐嶰嶐 崀嶐嵀 巰嶰巀嵐

嵀 巀庐-class .崐-C# 嶀幰嶐嶐崐嵐崀 庠嵐帠幠巠崀崐 庠嶐嶀嶀帐 嵀崰嵐庠巠巀 庠庐崠巀 巰庠嶐帀 崀巀 )庀巠嵐巀嶰 , 崀巀 嵐巀嶐幀崀嵀 崠嵐帐巠 嶀幰嶐嶐崐嵐崀 庠嵐帠幠巠崀崐-class巐嶐崀庠巠嵀 ( ,嵀 庠嵐帠幠巠崀崐 幰庀嵐 嶠崀 崀巀崀-class.

.NET 庠幀庐嵐 C# 庠嵐崰嵐庠巠 巐嶐庀嶀巠庀幀嵐

© 庐庀嶐幰 庀嶐巠崀 2

嵀崰嵐庠巠嵀 庠庀崰崠嵀 崐-C# 嶐幠崐幰 巐嶐巠嶐嶐幰 崀巀 .h巀嵐 嵀嵠庀嶰嵀 崠庐嵐巠嵀 巐嶐嶐幰 崀巀 巐崠 巰嶰)prototype (嵀崰嵐庠巠 嶐崐崠巀.

嵀 嶠嵐庠崐 庠庀崰崠嵐巠 嵀嶐嵀庠 崰嶐巠庠 嵀崰嵐庠巠-class.

巐嶐庀嶀巠庀幀

崐 嵀崠嵐嵀帀嵀 嵐嵠巀 嵀巠嵐崰 嵀庀嵐幠崐 巐嶐庀嶀巠庀幀 庠巀崐幰巠 嵀崰嵐庠巠-C++ ,巰嵐嶐幠巀 庠嵐崰嵰嵐嶐巠 庠嵐崰嵐幰帀 庀幀帐巠 巐帠:

嶐嶰庀帠 巰嶐嶐幠巀 巰庠嶐帀 崀巀default 崐-C# 巀崰嵰巠 庠庀嶐庀崐 巐帠 巐嶐庀嶀巠庀幀 巰嶐崀 )default parameters(, 巀嶰庐 崀嶐嵀 庠嵐帠巠庐巠嵀

嵀嶐巀崀 嵰巀庐嶐嵀巀 巐嶐崐嶐嶐嵰 庠庐庀嵐崰 嵀嶐幠幰帀嵐幀嵀庐 巐嶐庀嶀巠庀幀嵀 . 庠帐巠帠嵀崐 庐巠庠庐嵀巀 巰庠嶐帀巀 嵀巠嵐崰 崐幠巠 庀嵐幠嶐巀 嶐崰嶰崐 庠嵐嶐幠幰帀嵐幀-default parameters.

嵀庀嵐巠庐嵀 嵀巀嶐巠嵀ref

嵀庀嵐巠庐嵀 嵀巀嶐巠嵀 庠幀帐嵐嵀ref 巀崐幰庠嶐 庀嶀巠庀幀嵀庐 巰嶐嶐幠巠 庀嶀巠庀幀 嶐帀幀巀 By Reference ) 崀嶐嵀 嶠庀帠 嶐帀庠庐巠巀 巀崰嵰巠嵀 庠庀嶐庀崐By Value ,嵀 嶐帀庠庐巠巀 嶠庀帠 嶐帀庠庐巠 巰嶐崐 嵀帀嵰崐嵀

嶠庐巠嵀崐 嵀庐帠嶐庠 庠嵐帐嵰嶐嶐庠嵀 , 嵀幀庐崐 巐嶐嶐帐嶐帐崐嵀 巐嶐帀庠庐巠嵀 巀嶰庐 庀巠崀帀 幰庀 巐嶐嶐庠帀嶐崐– int, float嵐嶰嵐 '–嶠庀帠 嶐帀庠庐巠 巐帀嶐嵀 .(

嶰 庀嶀巠庀幀 嵐庠嵐崀 庠崀 巀崐幰巀 嵀幠嵐庀庐 嵀嶐幠幰帀嵐幀巀 庀嶀巠庀幀 巐嶐嵰巀嵐庐 庀庐崀嶰-ref , 巀帠 嵠嶐庀嶰嵀巀 嵀崐嵐嵰嶰 嵀嵰嶐巀庐嵀-ref嵀嶐幠幰帀嵐幀巀 嵀崀嶐庀幰崐 巐崠 .

嵀庀嵐巠庐嵀 嵀巀嶐巠嵀out

嶐巠嵀 嵀庀嵐巠庐嵀 嵀巀out 庀嶀巠庀幀 庠巀崐幰 嶠庀嵐幠巀 庠庐巠庐巠 By Reference 庠庀嵠嵰嵀 嶠庀嵐幠巀 嶠庀帠 . 嵀庀嵐巠庐嵀 嵀巀嶐巠崐 嶐帀嵐庀幰帠 巰幀嵐崀崐 庐巠庠庐嵀巀 巰庠嶐帀ref嵀嵠 嶠庀嵐幠巀 , 庀巀嶐嶐幀巠嵐幰嵀庐 崀巀崀

嶰 嵰巀庐帀庐 嵀帀庠庐巠庐 幰崰嵐崐-ref嶐庠巀嵰庠嵀 嶠庀帠 幰嶐嵠嵰巠 , 嵀帀庠庐巠庐 崰嵐帠崐out 嵰巀庐嶐嵀巀 巀嵐嶰嶐 巀嵐嵰庠嶐崀 崀巀巀 .帰帐嵐帀崐 ,嶰 嵰巀庐帀庐 嵀帀庠庐巠 嶐崐崠巀-out 庀巀嶐嶐幀巠嵐幰嵀 巀崐幰巠 嵀帀庠庐巠嵀庐 幰崰嵐崐

嵀崰嵐庠巠嵀 嶠嵐庠崐 嵀巠庐嵀. 嶰 庀嶀巠庀幀 嵐庠嵐崀 庠崀 巀崐幰巀 嵀幠嵐庀庐 嵀嶐幠幰帀嵐幀巀 庀嶀巠庀幀 巐嶐嵰巀嵐庐 庀庐崀嶰-out , 巀帠 嵠嶐庀嶰嵀巀 嵀崐嵐嵰

嶰 嵀嵰嶐巀庐嵀-out嵀嶐幠幰帀嵐幀巀 嵀崀嶐庀幰崐 巐崠 .

嵀庀嵐巠庐嵀 嵀巀嶐巠嵀params 嵀庀嵐巠庐嵀 嵀巀嶐巠嵀params 崀嶐嵀嵐 嵀嶐幠幰帀嵐幀嵀 巀庐 崰崐巀崐 巰嵐庀嵰崀嵀 庀嶀巠庀幀巀 帰帐嵐嵐庠嶐嵀巀 嵀巀嵐嶰嶐

嵀嶐幠幰帀嵐幀巀 嵰嵐巀庐巀 庠庀庐幀崀巠巰嵐庠帀 崠嵐帐巠 嶠庀帠巠嶰 巐嶐庀嶀巠庀幀 巀庐 帰帐嵐崀 .

.NET 庠幀庐嵐 C# 庠嵐崰嵐庠巠 巐嶐庀嶀巠庀幀嵐

© 庐庀嶐幰 庀嶐巠崀 3

庀嶀巠庀幀巀 嵀巠崠嵐崰ref:

1. class A 2. { 3. static void Main() 4. { 5. int i = 10; 6. new A().DoSomething(ref i); // i must be initialized 7. Console.WriteLine("i = {0}", i); 8. } 9. public void DoSomething(ref int refInt) 10. { 11. refInt++; 12. } 13. }

庀嶀巠庀幀巀 嵀巠崠嵐崰out:

1. class A 2. { 3. static void Main() 4. { 5. int i; 6. new A().DoSomething(out i); // i isn't initialized! 7. Console.WriteLine("i = {0}", i); 8. } 9. public void DoSomething(out int outInt) 10. { 11. outInt = 7; 12. } 13. }

庠崀 嵰嵐巀庐巀 嵀嶐嵀 庀庐幀崀庐 巰崐嵐巠嶰i崀嵐嵀 巐崀 巐崠 巀嵰庠嵐崀巠 嵀嶐嵀 .

庀嶀巠庀幀巀 嵀巠崠嵐崰params:

1. class A 2. { 3. static void Main() 4. { 5. int result; 6. result = new A().DoSomething(7, 1, 2, 3); 7. Console.WriteLine("result = {0}", result); 8. } 9. public int DoSomething(int times, params int[] arr) 10. { 11. int sum = 0; 12. for(int i=0; i<arr.Length; i++) 13. { 14. sum += arr[i]; 15. } 16. return sum * times; 17. } 18. }

.NET 庠幀庐嵐 C# 庠嵐崰嵐庠巠 巐嶐庀嶀巠庀幀嵐

© 庐庀嶐幰 庀嶐巠崀 4

庠嵐嶐幠幰帀嵐幀 庠帐巠帠嵀

崐 嵐巠嶰-C++ ,崐 巐崠-C#嵀 嵐庠嵐崀崐 巐庐 嵐庠嵐崀 巐帠 庠嵐嶐幠幰帀嵐幀 嶐庠庐 庀嵐幠嶐巀 巰庠嶐帀 -class . 嵐嵠 嵀帀嵐嶰庠 庠崀庀幰帀"庠嵐嶐幠幰帀嵐幀 庠帐巠帠嵀) "Functions Overloading.(

崐-C#嵐嶐嶰 崰嵰嵐嶐巠崐 庠嶐庐嵐巠嶐庐 崀嶐嵀 嵐嵠 嵀帀嵐嶰庠 巐嶐庀嶀巠庀幀巀 巀崰嵰巠 庠庀嶐庀崐 嶠庀帠 庠庠巀 巰庠嶐帀 崀巀庐 巰. 巀帠 巐嶐帀嵐庐 巐嶐庀嶀巠庀幀 巀崐幰巀 巰崐嵐巠嶰 庠嵐崐嶐嶐嵰 庠嵐嶐幠幰帀嵐幀嵀-巰嵀嶐帀嶐崐 巰嶐嵰崐嵀巀 帠崰嶐 庀巀嶐嶐幀巠嵐幰嵀庐 庠帀巠 .

嵀崀崐嵀 嵀崀嶐崠庐嵀 庠崀 巰庠嶐 庀巀嶐嶐幀巠嵐幰嵀 庠嵐嶐幠幰帀嵐幀 嶐庠庐 巰嶐崐 庀嵐嵰崐巀 嵰嶐巀幠巠 崀巀 庀巀嶐嶐幀巠嵐幰嵀嵐 嵀崰嶐巠崐: The call is ambiguous between the following methods or properties: …

庠嵐嶐幠幰帀嵐幀 庠帐巠帠嵀崐 巐嶐巀巀嶰 庀幀帐巠:

1. 庀嵠嵰嵐巠 嶠庀帠 崀嵐嵀 巰嵀嶐帀嶐崐 巀崰崐嵀嵀 巀嶰庐 庠嵐嶐幠幰帀嵐幀 帐嶐巠帠嵀巀 巰庠嶐帀 崀巀. 2. 巐嶐庀嶀巠庀幀嵀 崰嵰崀庐 崀嵐嵀 巰嵀嶐帀嶐崐 巀崰崐嵀嵀 巀嶰庐 庠嵐嶐幠幰帀嵐幀 帐嶐巠帠嵀巀 巰庠嶐帀 崀巀)庀庠嵐嶐 嵐崀 (

嶰 庠嵰崀崐 巀崐幰庠巠-ref嶰 嵀嶐帀庐崐嵐 -out. 3. 嵐庠崐 庠巀崐幰巠 庠嵰崀庐 崀嵐嵀 巰嵀嶐帀嶐崐 巀崰崐嵀嵀 巀嶰庐 庠嵐嶐幠幰帀嵐幀 帐嶐巠帠嵀巀 巰庠嶐帀 崀巀 庀嶀巠庀幀 庀

崠嵐帐 嵐庠嵐崀巠 嶠庀帠巠 巰嵐庀嵰崀 庀嶀巠庀幀嶰 庠巀崐幰巠 嵀嶐帀庐嵀嵐 巐嶐嶐嵐帐巠 崠嵐帐巠 嶠庀帠巠 巰嵐庀嵰崀 , 巀崐崀 崠嵐帐巠 庀嶀巠庀幀嶰params.

4. 庠嵐嶐幠幰帀嵐幀 帐嶐巠帠嵀巀 巰庠嶐帀 ,嵀 庀嶀巠庀幀嵀庐 庠嵰崀-X 嵀帀庠庐巠 崀嵐嵀 嵀巀庐 巰嵐庀嵰崀嵀嵐 params 巐嶐嶐嵐帐巠 崠嵐帐巠Y嵀 庀嶀巠庀幀嵀巠 巀嵰嵀 庠巀崐幰巠庐 嵀嶐帀庐嵀嵐 -X 嵐庠嵐崀巠 巐嶐庀嶀巠庀幀 巰嵐庀嵰崀巀 崰帠嵐

崠嵐帐Y .巀帠-巠帠嵀庐 嵀崀庀帀庐 帰崀 庠崀嶐崠庐巀 巐嵐庀崠巀 嵀巀嵐嶰嶐 嵐嵠嶰 嵀帐ambiguous call , 庀庠嵐嶐 嵀巀嶐帠嶐嵀 嵀崀嶐庀幰嵀 庠崀 庀嵐嵰崐巀 帠崰嵐嶐 庀巀嶐嶐幀巠嵐幰嵀) 崀巀 巐嶐庀嶀巠庀幀嵀 庠崀 庠巀崐幰巠庐 嵐嵠

嶠庀帠巠嶰.(

嵀巠崠嵐崰:

1. class A 2. { 3. static void Main() 4. { 5. int a = 10; 6. new A().DoSomething(a); 7. new A().DoSomething(5, 6); 8. new A().DoSomething(5, 6, 7); 9. new A().DoSomething(5, 6, 7, 8); 10. } 11. 12. public void DoSomething(ref refInt) {} 13. // The following func can't live together with the prev 14. // public void DoSomething(out refInt) {} 15. 16. public void DoSomething(int i) {} 17. public void DoSomething(int i, int j, int k) {} 18. public void DoSomething(params int[] arr) {} 19. // The following funcs can't live together with the prevs 20. // public void DoSomething(int[] arr) {} 21. // public void DoSomething(int i, params int[] arr) {} 22. }

嵀巀崀庐 : 嵀庀嵐庐 庠崀 巐嶐巠庐 嵐帀嶐嶐嵀 巐崀 嵀庀嵐幰 嵀嶐嵀 嵀巠16嵀庀帠嵀崐 ?

.NET 庠幀庐嵐 C# 巐嶐嶐嵐嶀嶐崐 )Statements(

© 庐庀嶐幰 庀嶐巠崀 5

巐嶐嶐嵐嶀嶐崐)Statements(

庠嵐幀帠庠帐嵀 嶐嶐嵐嶀嶐崐)Selection( if

崐 嵐巠嶰-C++ , 巀崐崀–崐 -C#巠 庠嶐嶀巠嵐嶀嵐崀 嵀庀巠嵀 巰嶐崀 -int巀 -bool巠 嵐崀 -null巀 -bool , 巰嶰巀庠庐庀嵐幀巠 嵀幰嶐崰崐 嵐嶐巀帠 帠幠崐巀 庐嶐 嶐帀崀嶐巀嵐崐 嶠庀帠 嵐帀帀嶐崀 嶐崀帀庠崐 嶐嵐嶀嶐崐嵀 庀庐崀嶰 ,巀庐巠巀:

崐嵀 嵀幰嶐崰崐嵀嵀嶐嵐崠庐 嵀崀 , 巀帠 嵀幰嶐崰崐 帠幠崐巀 巰庠嶐帀 崀巀庐 巰嵐嶐嶰int: int j = 10; if(j) { }

嵐帀嶐嵀 帰嶐巀嵰庠嵀: int j = 10; if(j != 0) { }

巰幀嵐崀 嵐庠嵐崀崐 ,嵀嶐嵐崠庐 嵀崀崐嵀 嵀幰嶐崰崐嵀 , 巀帠 嵀幰嶐崰崐 帠幠崐巀 巰庠嶐帀 崀巀庐 巰嵐嶐嶰null:

A a; // a is still a null reference // some code if(!a) { a = new A(); }

嵀 帰嶐巀嵰庠嵀嵐嵐帀嶐: A a; // a is still a null reference // some code if(a == null) { a = new A(); }

switch

崐 庐嵐巠嶐庐嵀-switch崐 -C#巀 嵀巠嵐崰 -C++ ,巐嶐崀崐嵀 巐嶐巀巀嶰嵀 嶀帠巠巀: 1. 崐-C# 帠幠崐巀 庀庠嵐巠 switch 庠嵐嵠嵐庀嵰巠 巀帠 巐崠 )崐 嵐巠嶰 巰嶐嶐崰帠嵐-C++ ,崐 巐嶐嶰庀帠嵀-case- 巐嶐

幀巠嵐幰 巰巠嵠崐 巐嶐帠嵐崰嶐嵐 巐嶐帠嵐崐幰 庠嵐嶐嵀巀 巐嶐崐嶐嶐嵰嵀嶐幠巀嶐.( 2. 巐嵐嶐帐崐case巀 庐嵐巀崠巀 庠嵐庀庐幀崀 巰嶐崀 -case 崀崐嵀 – 巀嶰 巐嵐嶐帐崐 case 庠崀 巰嶐嶐幠巀 嵀崐嵐嵰

庠嵐嶐嵐庀庐幀崀嵀巠 庠嵰崀 :break ,goto) 巀 巀巀嵐嶰-case嶠庐巠嵀崐 嵀巠崠嵐崰崐 嵀崀庀帀庐 嶐幀嶰 庀嵰崀 ( ,continue) 嵀崀巀嵐巀 帠幠巠崀崐 嵐帀嵰帀崀 巐崀 幰庀( ,return 嵐崀 throw.

) 庠嵰嶰嶐庐 巀庐 巐嶐帀崐幠帠巠 巐嶐崠崀崐 庠帠嶐帀巠 崀嶐嵀 嵀嵠 嶐嵐帀嶐庐巀 嵀崐嶐帐嵀break(.

嵀巠崠嵐崰:

1. void SwitchExample(string str) 2. { 3. switch(str) 4. { 5. case "Momo": 6. // do Momo thing ... 7. break; 8. case "Koko":

.NET 庠幀庐嵐 C# 巐嶐嶐嵐嶀嶐崐 )Statements(

© 庐庀嶐幰 庀嶐巠崀 6

9. // do Koko thing ... 10. break; 11. case "Dudu": 12. // do Dudu thing ... 13. // and then do also the default thing! 14. goto default; 15. case "Dadi": 16. // do Dadi thing ... 17. // and then do also Yoyo thing! 18. goto Yoyo; 19. case "Yoyo": 20. Yoyo: // this is a goto label 21. // do Yoyo thing ... 22. break; 23. case "Shooshoo": 24. // do Shooshoo thing ... 25. // and then get out of the function! 26. return; 27. case "Nuno": 28. // Nuno is not supposed to be here 29. throw new NunoIsNotInvitedException(); 30. default: // the default serves also as a goto label 31. // do default thing ... 32. break; // break is mandatory also here 33. } 34. // things after the switch 35. }

崐 庐巠庠庐嵀巀 巰庠嶐帀 崀巀 巀嶐帠巀 嵀巠崠嵐崰崐-continue 巐嵐嶐帐巀 case ,嵀 嶐嶰 嶀嵐庐幀-switch 崀幠巠帀 崀巀

嵀崀巀嵐巀 嶠嵐庠崐.

庠嵐崀巀嵐巀

for 帠 嵐巠嶰"嵀 巰幰庠 幀-ANSI 巀庐 C++ ,嵀 嶠嵐庠崐 庀崰崠嵐巠庐 嵀帀庠庐巠-for嵐巠幠帠 , 幐嵐嵰巠 庀嶰嵐巠 嵐帀帀嶐崀

嵀崀巀嵐巀巀 .巀庐巠巀: for(int j = 0; j < 10; j++)

嵀帀庠庐巠嵀j嵀崀巀嵐巀巀 幐嵐嵰巠 庀嶰嵐巠 嵀嶐嵀嶐 崀巀 ) 崐 嵀崀巀嵐巀嵀 庠崀 嵐帀庀崠帐 巐崀 巐崠- {}崀巀 巐崀 巐崠嵐 , 庠嶐巀巀嶰 嵀幠巀巠嵀–崐 嵀崀巀嵐巀 庀嵐崠帐巀 嶐嵐幠庀 崰嶐巠庠 - ,{} 巐崠 嵐巠嶰if.(

while-do, while

崐 嵐巠嶰-C++ , 嶐崐崠巀 庀巠崀帀庐 巀巀嶰嵀庐 庠崀 庀嵐嶰嵠巀 庐嶐if崐 巰嶐崀庐 嶠嶰巀 帠崠嵐帀崐 -C# 嵀庀巠嵀 巠 庠嶐嶀巠嵐嶀嵐崀-int巀 -bool巠 嵐崀 -null巀 -bool巰崀嶰 巐崠 帰幰庠 .

foreach

嵐巀 巀庐 庐崰嵰 崠嵐帐 嵐嵀嵠 巐嶐幀帐嵐崀 巀帠 嵀幠嶐庀 嶠庀嵐幠巀 崰帠嵐嶐巠庐 庠嵐崀巀) 嶐巀帠崐 巐嶐嶀幰嶐嶐崐嵐崀 巰嶰嵐 巐嶐嶰庀帠巠Indexer – 庀嵐嶀庀幀嵐崀 巀庐 嵀帐巠帠嵀巀 崰嵐崀巠 嵀巠嵐崰 巰嵐嶐帠庀 []崐-C++.(

庠崀巀嵐巀 嶠嵐庠崐foreach巐嶐幠庀 嵐嶐巀帠庐 帰帐嵐崀嵀 嵐崀 嶠庀帠巠嵀 巀帠 巐嶐嶐嵐帀嶐庐 帠幠崐巀 庀嵐帐崀 .

.NET 庠幀庐嵐 C# 巐嶐嶰庀帠巠

© 庐庀嶐幰 庀嶐巠崀 7

嵀帀嵐庐崀庀 嵀巠崠嵐崰) 庠嵐崀巀嵐巀 庐嵐崠幀帀foreach嶠庐巠嵀崐 巐崠 :( 1. public void DoSomething(int[] arr) 2. { 3. foreach(int k in arr) 4. { 5. Console.WriteLine("k={0}", k); 6. } 7. }

break, continue 崐 嵐巠嶰-C++ , 嵀崰嵐幰幀嵀 庠嵐帠幠巠崀崐 嵀崀巀嵐巀嵀 巀庐 嵀崀崐嵀 嵀嶐幠庀嶀嶐崀巀 庀嵐崐帠巀 巰庠嶐帀continue

嵀崰嵐幰幀嵀 庠嵐帠幠巠崀崐 嵀崀巀嵐巀嵀巠 庠崀幠巀 巰庠嶐帀嵐break) 庠嵐崀巀嵐巀嵀 嶐崠嵐帐 巀嶰巀 嶐嶀帀崐巀庀.(

巐嶐嶰庀帠巠

崰嵰 巐嶐嶰庀帠巠-巐嶐嶐崰巠嶐巠

崐 嶠庀帠巠 庠庀崰崠嵀崐-C#巀 崰嵐巠幠 巐嶐巠庐庀帀 巐嶐帠崐嵐庀巠嵀 巐嶐嶐庀崠嵐帐嵀 -type 嵐巠嶰 嶠庀帠巠嵀 巐庐 庀嵰崀巀 崀巀嵐 崐-C++) Java嵀崐嶐庠嶰嵀 庠嵐庀嵐幠 嶐庠庐 庠崀 庠庀庐幀崀巠 .(帰帐嵐帀崐 , 帠嵐崐幰巀 巰庠嶐帀 崀巀 嶠庀帠巠嵀 庠庀崰崠嵀崐

嶠庀帠巠嵀 巀崰嵐崠 庠崀–庠嶐巠帀嶐崰 嵀崀幠幰嵀崐 帠幠崐庠嵀巀 庠崐嶐嶐嵰 巀帠嵐幀崐 嶠庀帠巠嵀 庠庀嶐幠嶐 . 嵀巠崠嵐崰:

int[] arr = new int[5]; arr[0] = 3;

嶠庀帠巠 庀幠嶐嶐巀 庀庠嵐巠)庀巠嵐巀 庀庠嵐嶐 巰嵐嶰帀 嵀庐帠巠巀 ,Reference嶠庀帠巠巀 ( 庀嵰嵐崀巠 嵐庠嵐崀 庠嵐幠幰嵀巀嵐

庀庠嵐嶐: int[] arr; arr = new int[5];

崐 巐嶐嶰庀帠巠-C# 帐嶐帐崐 巀帠 巐嶐帐幰崰帀嵐崀巠 0) .NET 帐幰崰帀嶐崀 嶐巀帠崐 巐嶐嶰庀帠巠 庀嶐崰崠嵀巀 庠庀庐幀崀巠

巠 嵀帀嵐庐 嶐庠巀嵰庠嵀-0 庠嵐幀庐 庠嵐巠嶐嶐幰嵐 .NET嵐嵠 嵀嶐幠幀嵐崀崐 庠嵐嶰巠嵐庠庐 .C#崀崐 庠嶰巠嵐庠 嵀帀帀嶐崀 庠嵐庀庐幀巀嶐崠庀嵀 庀嶐崐嵰庠崐 嵐嵠 ,崐 巐崠 庠崀嵠 巐帠 嶠崀-C# 帐幀崀巠 嵀帀嵐庐 嶐庠巀嵰庠嵀 帐幰崰帀嶐崀 巐帠 嶠庀帠巠 庀幠嶐嶐巀 巰庠嶐帀

嵀嶐幠幰帀嵐幀巀 嵀崀嶐庀幰 庠嵐帠幠巠崀崐System.Array.CreateInstance.(

巐嶐嶰庀帠 庠巠嶐庐庀 庠嵐帠幠巠崀崐 巐崠 巐嶐嶰庀帠巠 巀嵰庠崀巀 巰庠嶐帀 ,巀庐巠巀: int[] arr = new int[]{1,2,3};

巰嶐嶀嵐巀嵰巀 巀嵐幰庐 巰幀嵐崀崐 嵐崀: int[] arr = {1,2,3};

.NET 庠幀庐嵐 C# 巐嶐嶰庀帠巠

© 庐庀嶐幰 庀嶐巠崀 8

崐-.NET 嶠庀帠巠嵀 庠嵐巀嵐崐崠巀 幐嵐嵰巠 帐幰崰帀嶐崀巀 巐嶐庐崠嶐帀嵐 嵀崰嶐巠崐嵐 嵀幠嶐庀 巰巠嵠崐 庠幰崰崐帀 嶠庀帠巠巀 嵀庐嶐崠 幰庀嵠嶐嶐Exception 崠嵐帐巠 IndexOutOfRangeException.

崐庀 巐嶐嶰庀帠巠-巐嶐嶐崰巠嶐巠 崐-C#巐嶐嶐崰巠嶐巠 崐庀 巐嶐嶰庀帠巠 巀庐 巐嶐崠嵐帐 嶐帀庐 巐嶐巠嶐嶐幰 : 巐嶐嶀嵐庐幀 巐嶐嶐帀崐巀巠 巐嶐嶰庀帠巠)rectangular (

巐嶐嶰庀帠巠 巀庐 巐嶐嶐巠帀嶐崰 巐嶐嶰庀帠巠嵐)jagged.(

rectangular arrays 崀崐嵀 巰幀嵐崀崐 庠帠幠崐庠巠 嶠庀帠巠嵀 庠庀嶐幠嶐:

int[,] arr = new int[,]{{1,2,3},{4,3,2}; 嵐崀:

int[,] arr = new int[2,3]; arr[0,0] = 1; arr[0,1] = 2; arr[0,2] = 3; arr[1,0] = 4; arr[1,1] = 3; arr[1,2] = 2;

庀庠嵐嶐 巀嵐崰崠 巐嶐崰巠嶐巠 庀幀帐巠 庀嵐幠嶐巀 巰崐嵐巠嶰 巰庠嶐帀: int[,,,] arr = new int[2,3,7,2]; arr[0,1,4,1] = 1;

)嵀嵠嶰 嶠庀帠巠崐 嶀嵐巀庐巀 嵀庐幰 庠幠幰庐 庠嵐庀巠巀.(

嶐幀巀 崐庐嵐嵰巠庐 巀崰嵐崠崐 巰嵐庀嶰嶐嵠崐 帰嵐幠庀 巐嵐幰巠 庠嵐幠幰嵀巀 崠崀嵐崰 庀巀嶐嶐幀巠嵐幰嵀 巐嶐嶐帀崐巀巠 巐嶐嶰庀帠巠 庀嵐崐帠嵀 巀崰嵐崠崐 巐嶐崰巠嶐巠嵀 巀嶰 巀崰嵐崠 庠巀幀嶰巠-Type嶠庀帠巠崐 幰嵠嵰嵐巠庐 .

jagged arrays 崀崐嵀 巰幀嵐崀崐 庠帠幠崐庠巠 嶠庀帠巠嵀 庠庀嶐幠嶐:

int[][] arr = new int[3][]; arr[0] = new int[1]; arr[1] = new int[2]; arr[2] = new int[]{1,2,3};

嶐嶰庀帠巠 巀庐 嶠庀帠巠 巰崀嶰 嵐帀巀崐嶐幰int- 巀崰嵐崠崐 巐嶐3庠嵐庀嵐庐 ,崰嵰崀 庀崐嶐崀 庐嶐 嵀帀嵐庐崀庀嵀 嵀庀嵐庐崐 ,

嵀嶐帀庐崐2 庠嶐庐嶐巀庐崐嵐 3) .崐-C++巀帠 嵀嵠嶰 嶠庀帠巠 巐嶐庀幠嶐嶐巠 嵐帀嶐嶐嵀 -巐嶐庀嶀帀嶐嵐幀崐 庐嵐巠嶐庐 嶐崰嶐 , 巀崐崀崐-C# 巐嶐庀嶀帀嶐嵐幀 巰嶐崀.(

庠嵐庀帠嵀: 1. 嵀 嶠庀帠巠 庠崀 庀崐嶰 嵐帀巀嵰庠嶐崀 庠嶐庐嶐巀庐嵀 嵀庀嵐庐崐-int- 巐嶐嶰庀帠崐 巐嶐1,2,3 . 崐巀 巐嶐庐巀 庐嶐

庠嵐帠幠巠崀崐 巀嵐嵰庠嶐崀 帠幠崐巀 嵀嵠 嵀庀幰巠崐 巰庠嶐帀 崀巀庐}1,2,3 {崰崐巀崐 ,崐 庐嵐巠嶐庐嵀-new int[] 嶐嵰庀嶰嵀 崀嵐嵀 嵀嵠 嵀庀幰巠崐.

2. 巀崐巀崐巠 嶀帠巠 庠嵐嶐嵀巀 巀嵐巀帠 庠嵐庀嵐庐嵀 嶠庀帠巠 庠庀嶐幠嶐巀 庀嶐崐嵰庠嵀) 庠帀嶐嵰崐巠庐 巰帠嶀嶐庐 嶐巠 嵀嶐嵀嶐帐帀嵐幰嶠嶰 帠幠崐庠嵀巀 嵀嶰嶐庀幠 嵀庠嶐嵀 嶠庀帠巠嵀 庠庀嶐幠嶐 庠嵐嶐嶀帀嶀帐嶐 :new int[][3] , 嵐帀嵰帀崀庐 巰嵐嶐嶰

.NET 庠幀庐嵐 C# 巐嶐嶰庀帠巠

© 庐庀嶐幰 庀嶐巠崀 9

巀崰嵐崠崐 嶠庀帠巠 庠嵐幠幰嵀巀 巐嶐幠嵐庀3 , 崠嵐帐巠int[] –嶐嵐崠庐 庀嶐崐嵰庠 嵐嵀嵠 巀崐崀 ,C# 嵀嶀嶐巀嵰嵀 嵀巀帠巠巀 帠嶐幀嵐巠嵀 嵀嵠 崀嵐嵀 巰嵐嶰帀嵀 庀嶐崐嵰庠嵀庐 .(

嶀幰嶐嶐崐嵐崀嶰 嶠庀帠巠嵀

崐 巐嶐嶰庀帠巠-.NET庀崐崰 巀嶰巀 巐嶐嶀幰嶐嶐崐嵐崀 嵀庐帠巠巀 巐嵀 . 巐嵐庐庀巀 巰庠嶐帀 "." 庀嵰崀巀 嶠庀帠巠 巀庐 巐庐嶠庀帠巠嵀 巀帠 庀庀崐巀 巰庠嶐帀庐 庠嵐帀嵐嶰庠 巰嶰嵐 嶠庀帠巠嵀 巀帠 巀嶐帠幀嵀巀 巰庠嶐帀庐 庠嵐崰嵐庠巠 巀庐 嵀巠嶐庐庀 巀崐幰巀嵐.

巀 崰嵐崠嶐帀崐-C++ ,崐 嵀崰嵐庠巠巀 嶠庀帠巠 巐嶐嵰巀嵐庐 庀庐崀嶰-C# ,嶠庀帠巠嵀 巀崰嵐崠 庠崀 巐崠 嵰嵐巀庐巀 嶠庀嵐幠 巰嶐崀 ,嵐巀崰嵐崠 庠崀 嵐巠嶐帠 崀庐嵐帀 嶠庀帠巠嵀庐 巰嵐嶐嶰 , 嵀帀嵐嶰庠嵀 庠嵐帠幠巠崀崐 嵀嵠 巰嵐庠帀 庀庀崐巀 巰庠嶐帀嵐Length.

崐 巐嶐嶰庀帠巠嵀 巀嶰-.NET 庠崀庀幰帀庐 嵀幰巀嵰巠巠 巐嶐庐庀嵐嶐 System.Array , 嵀巠幠帠崐 庠庐庀嵐嶐庐

嵀幰巀嵰巠嵀巠object . 巰帀嶐崀庐 巐嶐嶰庀帠巠崐 巀嵐幀嶐嶀巀 庠嵐嶐巀巀嶰 庠嵐崰嵐庠巠 崐嵐庠嶰巀 庠庀庐幀崀巠 嵐嵠 嵀崰崐嵐帠 嵐巀庐 巐嶐崰巠嶐巠嵀 庀幀帐巠巀 嵐巀嶐幀崀 嵐崀 嶠庀帠巠嵀 崠嵐帐巀 帐嵰嶐嶐庠嵀巀 庠嵐嶰嶐庀幠) 嶠庀帠巠庐 庠嵐帀嵐嶰庠嵀巠 庠嵰崀

嵀帀嶐嵀 帰庐嵐嵰Rank –嵐巀庐 巐嶐崰巠嶐巠嵀 庀幀帐巠 ,庐 嵐巀崰嵐崠 庠崀 庀庀崐巀 巰庠嶐帀 帰帐嵐帀崐 崰巠嶐巠 巀嶰崐 嶠庀帠巠嵀 巀 嵀嶐幠幰帀嵐幀嵀 庠嵐帠幠巠崀崐GetLength(int dimension) , 庀嶀巠庀幀嵀 庀庐崀嶰dimension 庠崀 巰嶐嶐幠巠

庐幰嵐崐巠嵀 崰巠嶐巠嵀 帐幰崰帀嶐崀.(

嵀巠崠嵐崰)庠嶰崐嵐帐巠 庠幠幰 ,巰嶐崐嵀巀 庀庐幀崀 嶀崀巀 嶀崀巀 巐嶐崐幰嵐帠 巐崀 巀崐崀:(

1. class PrintUtils 2. { 3. static public void PrintArray(System.Array arr) 4. { 5. // get the rank (num of dimensions) of the array we got 6. int rank = arr.Rank; 7. int[] indices = new int[rank]; 8. 9. // now we loop through all items by their order 10. // for example for a [2,2,3] array we should go 11. // through the following indices: 12. // [0,0,0], [0,0,1], [0,0,2], 13. // [0,1,0], [0,1,1], [0,1,2], 14. // [1,0,0], [1,0,1], [1,0,2], 15. // [1,1,0], [1,1,1], [1,1,2] 16. 17. // currDimension is the dimension we currently run on 18. // we start running on the last dimension 19. int currDimension = rank-1; 20. do 21. { 22. int len = arr.GetLength(currDimension); 23. // currIndex is the index within the currDimension 24. for(int currIndex = 0; currIndex < len; currIndex++) 25. { 26. indices[currDimension] = currIndex; 27. // Print the item of the current index 28. PrintItem(arr, indices); 29. } 30.

.NET 庠幀庐嵐 C# 巐嶐嶰庀帠巠

© 庐庀嶐幰 庀嶐巠崀 10

31. // reset the index of the dimension we went through 32. indices[currDimension] = 0; 33. 34. // find next dimension that should (can) be raised 35. while(currDimension > 0 && 36. indices[currDimension-1] == 37. arr.GetLength(currDimension-1) - 1) 38. { 39. currDimension--; 40. } 41. if(currDimension > 0) 42. { 43. // raise the dimension that should (can) be raised 44. indices[currDimension-1] = 45. indices[currDimension-1] + 1; 46. // set to zero all dimensions above the one raised 47. for(int i=currDimension; i<rank; i++) 48. { 49. indices[i] = 0; 50. } 51. // go back to play with the last dimension 52. currDimension = rank-1; 53. } 54. else // currDimension == 0 55. { 56. break; 57. } 58. } 59. while(true); 60. } 61. 62. // Print one item (with its position) 63. static private void PrintItem 64. (System.Array arr, int[] indices) 65. { 66. int initialRank = indices.Length; 67. for(int j=0; j<initialRank; j++) 68. { 69. Console.Write("[" + indices[j] + "]"); 70. } 71. object o = arr.GetValue(indices); 72. // special case: array of arrays 73. if(o.GetType().IsArray) 74. { 75. Console.WriteLine(" = "); 76. PrintArray((Array)o); 77. } 78. else 79. { 80. Console.WriteLine(" = " + o); 81. } 82. } 83. }

巀嶐帠巀 崰嵐幰嵀 庠崀 嵀幠嶐庀巠庐 庠嶐帀嶰嵐庠 嵀帀嵀嵐:

.NET 庠幀庐嵐 C# 巐嶐嶰庀帠巠

© 庐庀嶐幰 庀嶐巠崀 11

1. class PrintUtilsTest1 2. { 3. static void Main() 4. { 5. int[,,,,] iArrr = new int[2,1,3,1,1]; 6. iArrr[0,0,0,0,0] = 1; 7. iArrr[0,0,1,0,0] = 2; 8. iArrr[0,0,2,0,0] = 3; 9. iArrr[1,0,0,0,0] = 4; 10. iArrr[1,0,1,0,0] = 5; 11. iArrr[1,0,2,0,0] = 6; 12. PrintUtils.PrintArray(iArrr); 13. } 14. }

庠嶐帀嶰嵐庠嵀 巀庐 嶀巀幀嵀:

[0][0][0][0][0] = 1 [0][0][1][0][0] = 2 [0][0][2][0][0] = 3 [1][0][0][0][0] = 4 [1][0][1][0][0] = 5 [1][0][2][0][0] = 6

巀嶐帠巀 崰嵐幰嵀 庠崀 嵀幠嶐庀巠庐 庠嶐帀嶰嵐庠 崰嵐帠 嵀帀嵀嵐:

1. class PrintUtilsTest2 2. { 3. static void Main() 4. { 5. string[,] sArr; 6. PrintUtils.PrintArray(sArr = new string[,]{ 7. {"Hello","world"}, 8. {".NET","is cool"}, 9. {"and hot","at the same time"} 10. }); 11. 12. int[,,] iArr; 13. PrintUtils.PrintArray(iArr = new int[,,]{ 14. {{1,2},{3,4}}, 15. {{5,6},{7,8}} 16. }); 17. 18. PrintUtils.PrintArray(new object[]{iArr,sArr}); 19. } 20. }

庠嶐帀嶰嵐庠嵀 巀庐 嶀巀幀嵀嵐:

[0][0] = Hello [0][1] = world [1][0] = .NET [1][1] = is cool [2][0] = and hot [2][1] = at the same time [0][0][0] = 1 [0][0][1] = 2 [0][1][0] = 3

.NET 庠幀庐嵐 C# 巐嶐嶰庀帠巠

© 庐庀嶐幰 庀嶐巠崀 12

[0][1][1] = 4 [1][0][0] = 5 [1][0][1] = 6 [1][1][0] = 7 [1][1][1] = 8 [0] = [0][0][0] = 1 [0][0][1] = 2 [0][1][0] = 3 [0][1][1] = 4 [1][0][0] = 5 [1][0][1] = 6 [1][1][0] = 7 [1][1][1] = 8 [1] = [0][0] = Hello [0][1] = world [1][0] = .NET [1][1] = is cool [2][0] = and hot [2][1] = at the same time

嵀幰巀嵰巠巀 庀嵐嵠嵰帀Array –巀嶰巀 帐嶐帐崐 庠幰巀嵰巠 嵀庠嵐嶐嵀巀 帰帐嵐帀崐 巐嶐嶰庀帠巠嵀 , 嵀幰巀嵰巠嵀Array 巐嶐嶰庀帠巠崐 巀嵐幀嶐嶀巀 庠嵐嶐嶀嶀帐 庠嵐崰嵐庠巠 巀庐 嵀巠嶐庐庀 巐崠 庠幰幀帐巠)崐 庀嵐嶰嵠嶰庐 巰嵐嶐嶰-C# 庠庐崠巀 巰庠嶐帀 崀巀

嵀 庠嵐帠幠巠崀崐 幰庀嵐 嶠崀 崀巀崀 嶀幰嶐嶐崐嵐崀 庠嵐帠幠巠崀崐 庠嵐嶐嶀嶀帐 庠嵐崰嵐庠巠巀-class巐嶐崀庠巠嵀 , 庠嵐崰嵐庠巠嵀 嵀幰巀嵰巠嵀 巀庐 庠嵐嶐嶀嶀帐嵀Array 巐嶐巠庐嵐庀 嵐帀嵰帀崀 庀庐崀嶰 庠嵐崠幠嵐巠 巰帀嶐崀 "."嶠庀帠巠 巀庐 巐庐 庀嵰崀巀.(

嵀巠嶐庐庀庐 庠嵐嶐嶀嶀帐嵀 庠嵐崰嵐庠巠嵀 巀庐 庠嶐幰巀嵰 -Array嵀帠嶐幠巠 : • BinarySearch • Copy

• Reverse • Sort

嵐 帠幀嵐巠 庠嵐崰嵐庠巠-Properties巀帠 巐嶐帠幠嵐巠庐 巐嶐嶐庀幰嶐帠 -巐嶐嶰庀帠巠 嶐崰嶐:

• Clone • CopyTo • IndexOf

• GetLength(dimension) • Length • Rank

嵀嶐幠幰帀嵐幀巀 庀嶀巠庀幀嶰 嶠庀帠巠 庠庀崐帠嵀

巀 崰嵐崠嶐帀崐-C++ ,崐-.NET幀巀 嶠庀帠巠 庀崐帠嵐巠 庀庐崀嶰 嵀嶐幠幰帀嵐 , 崀巀崀 嶠庀帠巠嵀 巀庐 幰庠嵐帠 庀崐帠嵐巠 崀巀Reference 嶠庀帠巠嵀 巀庐 )崐 庀嶀帀嶐嵐幀 庠庀崐帠嵀巀 嵀巠嵐崰崐-C++ .( 嵀帀庐帀 巐崀庐 崀嶐嵀 庠嵐帠巠庐巠嵀

嶠庀帠巠崐 巐嶐嶰庀帠 ,嵀帀庠庐嶐 嶐庀嵐幰巠嵀 嶠庀帠巠嵀.

巀庐 巐嶐幀帐嵐崀嵀 庠嵐幰巀嵰巠.NET

庠崐嶐崐帐崐 巐嶐巠嶐嶐幰 巐嶐嶀嵐庐幀嵀 巐嶐嶰庀帠巠嵀 崰幠巀.NET嵐巠嶰 巐嶐嶐巠帀嶐崰 巐嶐幀帐嵐崀 巀嵐嵀嶐帀巀 庠嵐幰巀嵰巠 :

.NET 庠幀庐嵐 C# 嶐帀庠庐巠 嶠庀帠 嶐帀庠庐巠嵐 庠嵐帐嵰嶐嶐庠嵀

© 庐庀嶐幰 庀嶐巠崀 13

- System.Collections.ArrayList - System.Collections.Hashtable - System.Collections.Stack

崰嵐帠嵐.

巐帀嶐嵀 巐嶐幀帐嵐崀嵀 庠嵐幰巀嵰巠 巀庐 庠嵐帀嵐庀庠嶐嵀: • 嶐巠帀嶐崰 巀崰嵐崠. • 巐嶐嶰庀帠 嶐崠嵐帐 崐嵐巀嶐庐巀 庠嵐庀庐幀崀)崐 庐嵐巠嶐庐 嶠嵐庠-Polymorphism.( • 帰帐嵐崀嵀 巀帠 嵀帀崠嵀巀 庠嵐庀庐幀崀 ,巀帠-庐巠庠庐巠巀 崰崐巀崐 嵀崀嶐庀幰 庠嵐嶐幠幰帀嵐幀 庠幀嶐庐嵰 嶐崰嶐.

巐嶐嶰庀帠巠 巀庐 庠嵐帀嵐庀庠嶐嵀:

• 庀帠巠 巐嶐巀嶐帠嶐 巐嵀 巐嶐嶰=)巐嶐庀嶐嵀巠 (庀庠嵐嶐 , 嶠庀帠巠嵀 巀嶰 巀帠 幐嵐庀巀 庐庀崰帀 崀巀 巰崐嵐巠嶰 崰嵐帠 巀嶰 嶠庀帠 庐幀嵰巀 嶐崰嶰–庐 嵰嶐帀嵀巀 庀嶐崐帐 嵀嵠嶰 崐幠巠崐 -Hashtable巀嶐帠嶐 庀庠嵐嶐 嵀嶐嵀嶐 .

• 崰嵐幰 庠嵐嶀庐幀)嶠庀帠巠崐 庐巠庠庐嵀巀 巀幰嵐 嶀嵐庐幀 庀庠嵐嶐 帠嵐崐幰 巀崰嵐崠崐 帰帐嵐崀 庐庀崰帀 庀庐崀嶰.(

庠嵐帐嵰嶐嶐庠嵀 嶐帀庠庐巠嵐 嶠庀帠 嶐帀庠庐巠 崐-.NET巐嶐帀庠庐巠 嶐崠嵐帐 嶐帀庐 巐嶐巠嶐嶐幰 :

- 嶠庀帠 嶐帀庠庐巠)Value-Type( - 庠嵐帐嵰嶐嶐庠嵀 嶐帀庠庐巠)Reference-Type(

嶠庀帠 嶐帀庠庐巠)Value-Type(

嵀 巀帠 巐嶐庀幠嵐帀 嶠庀帠 嶐帀庠庐巠-stack) 巐嵀巀 巐嶐帠幠崐巠 庀庐崀嶰 巐崠new( , 嵀巠庐嵀崐 巐嶐幰庠帠嵐巠 巐嵀 庠嵐嶐幠幰帀嵐幀巀 巐嶐庀崐帠嵐巠嵐By Value.

嵀 庠崀 巐嶐巀巀嵐嶰 嶠庀帠 嶐帀庠庐巠-Types巐嶐崀崐嵀 :

• enums巀帠 嵐庀崰崠嵐嵀庐 -巀帠 嵐崀 嵀幀庐嵀 嶐崰嶐-巠嵀 嶐崰嶐庐巠庠庐. • structs巀帠 嵐庀崰崠嵐嵀庐 -巀帠 嵐崀 嵀幀庐嵀 嶐崰嶐-庐巠庠庐巠嵀 嶐崰嶐.

嵀-bullet 庠崀 嵐嶰嵐庠崐 巀巀嵐嶰 嶐帀庐嵀 "巐嶐嶐帐嶐帐崐嵀 巐嶐帐嵐幀嶐嶀嵀) "simple types ,basic types 嵐崀

primitive types( ,巀帠 巐嶐庀崰崠嵐巠庐 巐嶐帐嵐幀嶐嶀 巀庐 嵀巠嶐庐庀- 嶐崰嶐.NET嶰 -structs ,庠崀 庠巀巀嵐嶰嵀 嵀-Types巐嶐崀崐嵀 :

bool ,byte ,char ,decimal ,double ,float ,int ,long ,sbyte ,short ,uint ,ulong ,ushort. 巐嶐帐嵐幀嶐嶀嵀庐 崐巀 巐嶐庐巀 庐嶐string嵐 -object 嵀巠嶐庐庀崐 巐帀嶐崀 )庠嵐帐嵰嶐嶐庠嵀 嶐帀庠庐巠 巐嵀.(!

嵀 巀嶰-Value-Types崐 -.NET) 巀巀嵐嶰Value-Types庀幠嶐嶐庠庐 巐嶐庐崰嵰 ( , 庠嶐嶀巠嵐嶀嵐崀 巐嶐庐庀嵐帀

嵀幰巀嵰巠嵀巠System.ValueType) 巠 庠庐庀嵐帀庐-System.Object.( 嵀 嵀帀嵀嵀 巀嶰 巀庐 嵀崀巀巠嵀 嵀巠嶐庐庀-Value-Types嵀巠 幰巀嵰 巐嵀庐 -Class Library:

.NET 庠幀庐嵐 C# 嶐帀庠庐巠 嶠庀帠 嶐帀庠庐巠嵐 庠嵐帐嵰嶐嶐庠嵀

© 庐庀嶐幰 庀嶐巠崀 14

System.Object System.ValueType System.ArgIterator System.Boolean = simple type bool System.Byte = simple type byte System.Char = simple type char System.Collections.DictionaryEntry System.Collections.Specialized.BitVector32 System.Collections.Specialized.BitVector32.Section System.Configuration.Assemblies.AssemblyHash System.Data.SqlTypes.SqlBinary System.Data.SqlTypes.SqlBoolean System.Data.SqlTypes.SqlByte System.Data.SqlTypes.SqlDateTime System.Data.SqlTypes.SqlDecimal System.Data.SqlTypes.SqlDouble System.Data.SqlTypes.SqlGuid System.Data.SqlTypes.SqlInt16 System.Data.SqlTypes.SqlInt32 System.Data.SqlTypes.SqlInt64 System.Data.SqlTypes.SqlMoney System.Data.SqlTypes.SqlSingle System.Data.SqlTypes.SqlString System.DateTime System.Decimal = simple type decimal System.Diagnostics.CounterSample System.Diagnostics.SymbolStore.SymbolToken System.Double = simple type double System.Drawing.CharacterRange System.Drawing.Color System.Drawing.Point System.Drawing.PointF System.Drawing.Rectangle System.Drawing.RectangleF System.Drawing.Size System.Drawing.SizeF System.EnterpriseServices.BOID System.EnterpriseServices.XACTTRANSINFO System.Enum = base class for all enums … System.Data.AcceptRejectRule System.Data.CommandBehavior System.Data.CommandType System.Data.ConnectionState … System.Guid System.Int16 = simple type short System.Int32 = simple type int System.Int64 = simple type long System.IntPtr System.IO.WaitForChangedResult System.Reflection.Emit.EventToken System.Reflection.Emit.FieldToken System.Reflection.Emit.Label System.Reflection.Emit.MethodToken System.Reflection.Emit.OpCode System.Reflection.Emit.ParameterToken System.Reflection.Emit.PropertyToken

.NET 庠幀庐嵐 C# 嶐帀庠庐巠 嶠庀帠 嶐帀庠庐巠嵐 庠嵐帐嵰嶐嶐庠嵀

© 庐庀嶐幰 庀嶐巠崀 15

System.Reflection.Emit.SignatureToken System.Reflection.Emit.StringToken System.Reflection.Emit.TypeToken System.Reflection.InterfaceMapping System.Reflection.ParameterModifier System.Runtime.InteropServices.ArrayWithOffset System.Runtime.InteropServices.BIND_OPTS System.Runtime.InteropServices.BINDPTR System.Runtime.InteropServices.CONNECTDATA System.Runtime.InteropServices.DISPPARAMS System.Runtime.InteropServices.ELEMDESC System.Runtime.InteropServices.ELEMDESC.DESCUNION System.Runtime.InteropServices.EXCEPINFO System.Runtime.InteropServices.FILETIME System.Runtime.InteropServices.FUNCDESC System.Runtime.InteropServices.GCHandle System.Runtime.InteropServices.HandleRef System.Runtime.InteropServices.IDLDESC System.Runtime.InteropServices.PARAMDESC System.Runtime.InteropServices.STATSTG System.Runtime.InteropServices.TYPEATTR System.Runtime.InteropServices.TYPEDESC System.Runtime.InteropServices.TYPELIBATTR System.Runtime.InteropServices.VARDESC System.Runtime.InteropServices.VARDESC.DESCUNION System.Runtime.Serialization.SerializationEntry System.Runtime.Serialization.StreamingContext System.RuntimeArgumentHandle System.RuntimeFieldHandle System.RuntimeMethodHandle System.RuntimeTypeHandle System.SByte = simple sbyte (signed) System.Security.Cryptography.DSAParameters System.Security.Cryptography.RSAParameters System.Single = simple type float System.Threading.LockCookie System.Threading.NativeOverlapped System.TimeSpan System.TypedReference System.UInt16 = simple type ushort (unsigned) System.UInt32 = simple type uint (unsigned) System.UInt64 = simple type ulong (unsigned) System.UIntPtr System.Void System.Web.UI.WebControls.FontUnit System.Web.UI.WebControls.Unit System.Windows.Forms.BindingMemberInfo System.Windows.Forms.DataGridCell System.Windows.Forms.LinkArea System.Windows.Forms.Message

.NET 庠幀庐嵐 C# 嶐帀庠庐巠 嶠庀帠 嶐帀庠庐巠嵐 庠嵐帐嵰嶐嶐庠嵀

© 庐庀嶐幰 庀嶐巠崀 16

庠嵐帐嵰嶐嶐庠嵀 嶐帀庠庐巠)Reference-Type(

嵀 巀帠 巐嶐庀幠嵐帀 庠嵐帐嵰嶐嶐庠嵀 嶐帀庠庐巠-heap , 嵀巠庐嵀崐 庠庀崐帠嵐巠 崰崐巀崐 巐嵀嶐巀崀 庠嵐帐嵰嶐嶐庠嵀嵀) 崀巀嵐嶠庀帠嵀 ( 庠嵐嶐幠幰帀嵐幀巀 巐嶐庀崐帠嵐巠 巐嵀嵐By Reference.

嵀 庠崀 巐嶐巀巀嵐嶰 庠嵐帐嵰嶐嶐庠嵀 嶐帀庠庐巠-Types巐嶐崀崐嵀 :

• classes巀帠 嵐庀崰崠嵐嵀庐 -巀帠 嵐崀 嵀幀庐嵀 嶐崰嶐-庐巠庠庐巠嵀 嶐崰嶐. • 巐嶐嶰庀帠巠)巀庐 巐嶐嶰庀帠巠 巀巀嵐嶰 Value-Types 嵐巠嶰 int巀庐巠巀 .( • delegates巀帠 嵐庀崰崠嵐嵀庐 -巀帠 嵐崀 嵀幀庐嵀 嶐崰嶐- 庐巠庠庐巠嵀 嶐崰嶐) 巀帠delegates 庀崐崰帀

嶠庐巠嵀崐.(

帐嵐幀嶐嶀嵀string 崠嵐帐巠 帐嵐幀嶐嶀 嵐帀嶐嵀 巀庐巠巀 Reference-Type . 庀崰崠嵐巠嵀 帐嵐幀嶐嶀 嵀庐帠巠巀 嵐嵀嵠 巀帠- 嶐崰嶐C# 嵀嵐嵐嵀巠嵐 "嶐嵐帀嶐嶰 " 嵀幰巀嵰巠巀System.String ,巠 庠嵐庀嶐庐嶐 庠庐庀嵐嶐庐-System.Object

) 嵀幰巀嵰巠嵀巠 崀巀嵐System.ValueType.(

巀庐 嵀庀嶐嵰崐嵀庐 嶠嶰巀 崐巀 巐嶐庐巀 庐嶐.NET嶰 巐嶐嶰庀帠巠巀 帐嵰嶐嶐庠嵀巀 -Reference-Type 嵀庀嶐嵰崐 崀嶐嵀 崰嵐崀巠 嵀巀嶐帠嶐 .巀 崰嵐崠嶐帀崐庐 崀嶐嵀 庠嵐帠巠庐巠嵀-C++ , 幰庠嵐帠 庀崐帠嵐巠 崀巀 嵀崰嵐庠巠巀 嵰巀庐帀 嶠庀帠巠 庀庐崀嶰

嶐庀嵐幰巠嵀 嶠庀帠巠嵀 崀巀崀 嶠庀帠巠嵀 巀庐.

嵀巠崠嵐崰:

1. class A 2. { 3. static public void Main(string[] args) { 4. Reverse(args); 5. foreach(string arg in args) { 6. System.Console.WriteLine(arg); 7. } 8. } 9. static private void Reverse(string[] args) { 10. System.Array.Reverse(args); 11. } 12. }

巐嶐庀嶀巠庀幀嵀 巐帠 庠嶐帀嶰嵐庠嵀 庠崀 幐嶐庀帀 巐崀 :One Two Three ,嵐幀嵀 庀崰帐崐 嵐帐幀崰嵐嶐 庠嵐嵠嵐庀嵰巠嵀嶠.

嵀巠崠嵐崰 崰嵐帠:

1. using System.Text; 2. 3. class A { 4. static public void Main() { 5. // int array 6. int[] intArr = {1,2,3}; 7. PlayWithArray(intArr); 8. foreach(int i in intArr) { 9. System.Console.WriteLine(i); 10. } 11. // StringBuilder array 12. StringBuilder[] sbArr = new StringBuilder[2]; 13. sbArr[0] = new StringBuilder("First");

.NET 庠幀庐嵐 C# 嶐帀庠庐巠 嶠庀帠 庐巠嵐嶐帀庠 庠嵐帐嵰嶐嶐庠嵀

© 庐庀嶐幰 庀嶐巠崀 17

14. sbArr[1] = new StringBuilder("Second"); 15. PlayWithArray(sbArr); 16. foreach(StringBuilder sb in sbArr) { 17. System.Console.WriteLine(sb); 18. } 19. } 20. static private void PlayWithArray(int[] arr) { 21. for(int i = 0; i < arr.Length; i++) { 22. arr[i]++; 23. } 24. arr = new int[]{17,53}; // just for the example 25. } 26. static private void PlayWithArray(StringBuilder[] sbArr) { 27. foreach(StringBuilder sb in sbArr) { 28. sb.Replace('c', '#'); 29. sb.Replace('s', 'c'); 30. sb.Replace('#', 's'); 31. } 32. } 33. }

崀嵐嵀 庠嶐帀嶰嵐庠嵀 巀庐 嶀巀幀嵀:

2 3 4 Firct Sesond

庠嵐崀庀巀 巰庠嶐帀庐 嶐幀嶰 , 庠嵐庀嵐庐巀 崰嵐崠嶐帀崐23-21嶐庀嵐幰巠嵀 嶠庀帠巠嵀 巀帠 庠嵐帠嶐幀庐巠庐 , 嵀庀嵐庐24 嵀帀帀嶐崀

嶐庀嵐幰巠嵀 嶠庀帠巠嵀 巀帠 嵀帠嶐幀庐巠)嶀巀幀嵀 巀帠 嵀帠幀庐嵀 嵀巀 巰嶐崀 巰嶰巀嵐 (–嵀巠巀 ?

嵀庀帠嵀: 嵀庀嵐庐 庠崀21崀巀嵐巀崐 帰嶐巀嵰嵀巀 嵀嶐嵀 巰庠嶐帀 崀巀 庠foreach) .嵀巠巀?(

嵠巠庀 :嵀 庠崀巀嵐巀 嶠嵐庠崐 嵀崀崐嵀 嵀庀嵐庐嵀 庠崀 帠幠崐巀 嵀嶐嵀 巰庠嶐帀 崀巀庐 嵀崐嶐帐 嵀庠嵐崀巠-foreach 巀庐 庠嵐庀嵐庐31-27:

sb = new StringBuilder("A new StringBuilder"); ) 庠崀巀嵐巀崐 巀崐崀for庀庐幀崀 嵀嶐嵀 .(!

嶰 庀嶀巠庀幀 庠嵰嶐巀庐崐 庐嵐巠嶐庐 庠嵐庐帠巀 巰庠嶐帀-ref嶰 嵐崀 -out , 崠嵐帐巠 庀嶀巠庀幀崐 庀崐嵐崰巠 庀庐崀嶰 巐崠Reference-Type . 庀嶀帀嶐嵐幀 嵐崀 庀嶀帀嶐嵐幀巀 庀嶀帀嶐嵐幀 庠庀崐帠嵀巀 嵀巠嵐崰 巰嵐嶐帠庀嵀ByRef崐 -C++.

嵀庀嵐庐崐 巐嶐巀崐幰巠 嵐帀嶐嶐嵀 庠巠崰嵐幰嵀 嵀巠崠嵐崰崐 巀庐巠巀 巐崀20 嵀帀庠庐巠嶰 嶠庀帠巠嵀 庠崀 ref) 巐崠 巰崐嵐巠嶰嵐 嵀庀嵐庐崐 嵀嵠嶰嶰 嵐庠嵐崀 巐嶐嵰巀嵐庐7( , 嵀庀嵐庐巀 嵠崀24 嵀嶐嵀 嶀巀幀嵀嵐 嶐庀嵐幰巠嵀 嶠庀帠巠嵀 巀帠 嵀帠幀庐嵀 嵀庠嶐嵀

嶠嶰 嵀崀庀帀: 17 53 Firct Sesond

.NET 庠幀庐嵐 C# 嶐帀庠庐巠 嶠庀帠 嶐帀庠庐巠嵐 庠嵐帐嵰嶐嶐庠嵀

© 庐庀嶐幰 庀嶐巠崀 18

嵐帀 嵀巠崠嵐崰庠幀帐:

1. class A 2. { 3. static public void Main() 4. { 5. int[] arr; 6. CreateArray(out arr); 7. foreach(int ii in arr) { 8. System.Console.WriteLine(ii); 9. } 10. } 11. static public void CreateArray(out int[] arr) 12. { 13. arr = new int[]{1,2,3}; 14. } 15. }

幀嶰 嶠庀帠巠 嵐帀庀崐帠嵀 嵐嵠 嵀巠崠嵐崰崐 庀嶀巠庀out巀帠 -巀嵰庠嵐崀巠 嶠庀帠巠 嵀庀嵠嵰崐 巀崐幰巀 庠帀巠.

崠嵐帐巠 崠嵐帐巠 庠嵐崰庐 巀嶐嶰嵀巀 巰庠嶐帀庐 巰嶐嶐幠巀 崐嵐庐嵰Reference-Type 嶠嵐庠崐 巐崠 struct 嵐巀崀 庠嵐崰庐嵐 巀庐 巐嶐巀嶐崠庀嵀 巐嶐巀巀嶰嵀 嶐幀巀 嵐崠嵀帀庠嶐Reference-Type :嵀 庀庐崀嶰-struct 嵐崀 嵀嶐幠幰帀嵐幀巀 庀崐帠嵐嶐

幰庠帠嵐嶐 ,嵀 嵀崰庐 巐崀-Reference 嵐嶰庀帠 庠崀 嵀帀庐嶐 –崐 巐崠 嵀帀庠庐嶐 嶠庀帠嵀 -struct嶐庀嵐幰巠嵀 .

嵀巠崠嵐崰:

1. using System.Text; 2. 3. public class Structs { 4. public static void Main() 5. { 6. SomeStruct some1; 7. some1.sb = new StringBuilder("1"); 8. SomeStruct some2 = some1; 9. some2.sb.Append("!"); 10. System.Console.WriteLine(some1.sb); 11. } 12. } 13. 14. struct SomeStruct { 15. public StringBuilder sb; 16. }

崀嵐嵀 庠嶐帀嶰嵐庠嵀 巀庐 嶀巀幀嵀: 1!

崐 嵀庐帠帀庐 嶐嵐帀嶐庐嵀庐 巰崐嵐巠嶰 嵀崀庀巠庐 嵀巠-some2 嵀庀嵐庐崐 9 巀帠 巐崠 帠嶐幀庐嵀 some1.

嵀庀帠嵀: 崐 庐嵐巠嶐庐嵀-new 嵀帀庠庐巠 庠庀嶐幠嶐巀 struct巀帠 崰帠嵐帀 - 嵐帀帀嶐崀 崀嵐嵀 嶠崀 嵀帀庠庐巠嵀 庠崀 巀嵰庠崀巀 庠帀巠

嶐嵰庀嶰嵀–嵀 巀帠 嵐巠嵐幰巠 庠崀 帐幀嵐庠嵐 巐嶐嶐幰 嵀帀庠庐巠嵀 -stack 崀巀巀 巐崠new , 庠嵐崀庀巀 巰庠嶐帀庐 嶐幀嶰 嵀庀嵐庐崐 巀嶐帠巀 嵀巠崠嵐崰崐6嵀 巀庐 嵀崰庐巀 嵀庐嶐崠崐嵐 -struct 嵀庀嵐庐崐 7.

.NET 庠幀庐嵐 C# 嶐帀庠庐巠 嶠庀帠 嶐帀庠庐巠嵐 庠嵐帐嵰嶐嶐庠嵀

© 庐庀嶐幰 庀嶐巠崀 19

巐嶐巀嵐嵰庠嶐崀Default-嵐 巐嶐-Null Reference

巐嶐嶐巀幰嵐巀 巐嶐帀庠庐巠 崐-C# 嶠庀帠巀 巐嶐巀嵰庠嵐崀巠 巐帀嶐崀 巐嶐嶐巀幰嵐巀 巐嶐帀庠庐巠 default嶐庠巀嵰庠嵀 . 庐嵐巠嶐庐 嵀庐帠帀 庀庐崀嶰

嶐巀幰嵐巀 嵀帀庠庐巠崐 , 嵀幠嶐庀嵀 嶐巀嵐巀帐巠 巀嶰 巐崀嵀 幰嵐崰崐嶐 庀巀嶐嶐幀巠嵐幰嵀 嵀帀庠庐巠嵀庐 嶠嶰巀 嵐崠崀崰 巐嶐嶐庀庐幀崀嵀巀嵰庠嵐崀嶐 .庠嶐巀嶐巀庐 崀嶐嵀 嵀崐嵐庐庠嵀 巐崀 ,嵀嶐幠巀嶐幀巠嵐幰 庠崀嶐崠庐 巀崐幰帀:

Use of unassigned local variable '<var>'

庀嵐崐帠Value-Type 巀嵐嵰庠嶐崀 庐庀崰帀 嶐庠嶐巠崀嶠庀帠 巀庐 . 庀嵐崐帠Reference-Type庠崀嵠 庠巠嵐帠巀 , 嶠庀帠崐 巀嵐嵰庠嶐崀 帠幠崐巀 巰庠嶐帀null . 嵀帐帀帀 庠巠崀崐 巐崀 巐帀巠崀

巀帠 嵀崰嵐庠巠 巀嶐帠幀嵀巀Null Reference 帰嵐嶀嵰帀 Exception嵀幠嶐庀 巰巠嵠崐 : System.NullReferenceException: Object reference not set to an instance of an object.

嵰嵐巀庐巀 庀庠嵐巠Null Reference) Reference-Type崐 巀嵰庠嵐崀庐 -null (嵀嶐幠幰帀嵐幀巀 , 巐崀 嵐巀嶐幀崀

嶰 嵐庠嵐崀 巀崐幰巀 嵀帐帀巠 崀嶐嵀-ref .帰幰庠 巰崐嵐巠嶰 巐崰嵐幰嵀 巀巀嶰嵀 :嵐嶐帐嶐帀 嵀帀庠庐巠嵀 巀帠 嵀崰嵐庠巠 巀嶐帠幀嵀巀 巰巀 巐嵐庀崠嶐-Exception.

嵀幰巀嵰巠 嶐帀庠庐巠

嵀幰巀嵰巠 嶐帀庠庐巠– 嶐帀庠庐巠 instance巐嶐嶐嶀嶀帐 巐嶐帀庠庐巠 嵐崀 , 嶠庀帠巀 巐嶐巀嵰庠嵐崀巠default:

- Value-Types帐幀崀巀 巐嶐巀嵰庠嵐崀巠 ,false嵐嶰嵐 '. - Reference-Types巀 巐嶐巀嵰庠嵐崀巠 -null.

巐嶐嶰庀帠 巐嶐巠嶐嶐幰庐 嵀崰崐嵐帠嵀 庠嵐庀巠巀default-巐嶐 ,庐巠 巀嵰庠崀帀 崀巀 庀庐崀嶰嵀幰巀嵰巠 嶐帀庠 , 庀巀嶐嶐幀巠嵐幰嵀嵀 庠崀 巰庠嶐-warning崀崐嵀 :

Field '<class>.<field>' is never assigned to, and will always have its default value <default value for this type>

嵀幰巀嵰巠 嶐帀庠庐巠 巐崠 巀嵰庠崀巀 嵀庀幰巠 巀嶰崐 嶐嵐幠庀 巰嶰巀.

巐嶐嶰庀帠 庠崀嵐嵐庐嵀– Value-Types 庠巠嵐帠巀 Reference-Types

崀嵐嵐庐嵀 巰嶐崐 嵀帀嵐庐 巰幀嵐崀崐 庠崠嵀帀庠巠 巐嶐嶰庀帠 庠Value-Types巀 -Reference-Types. 庀嵐崐帠Value-Types嵐巠幠帠 嶠庀帠嵀 巀庐 嵀崀嵐嵐庐嵀 庠帠幠崐庠巠 , 庀嵐崐帠庐 崰嵐帠崐Reference-Type

嵀 巀庐 嵀崀嵐嵐庐嵀 庠帠幠崐庠巠-Reference) 庀巠嵐巀嶰– 嵀嶐嵀庠 嵀崀幠嵐庠嵀 true 嵐庠嵐崀崐 庀崐嵐崰巠 巐崀 幰庀 庐巠巠 嶀幰嶐嶐崐嵐崀嵀 .( 庀嵐嶀庀幀嵐崀 巀庐 嵀帐巠帠嵀 帠幠崐巀 巰庠嶐帀 ==嶐帀 巰嶰嵐 嵀嶐幠幰帀嵐幀嵀 庠崀 庐崰嵰巠 庐巠巠巀 巰庠

Equals) 庀嵐崐帠 巰嵀Value-Type 庀嵐崐帠 巰嵀嵐 Reference-Type( ,嵐 嵀帐巠帠嵀 嵀庠庐帠帀嵐 嵀崰嶐巠崐/ 嵐崀 嵀嶐幠幰帀嵐幀嵀Equals庐崰嵰巠 嵀崐庠嶰帀 ,嵐巀崀 庠嵐嶐幠幰帀嵐幀 巀庐 庐嵐巠嶐巠崐 巰崐嵐巠嶰 嵀嶐嵐巀庠 嵀嶐嵀庠 嵀崀幠嵐庠嵀.

.NET 庠幀庐嵐 C# 嶐帀庠庐巠 嶠庀帠 嶐帀庠庐巠嵐 庠嵐帐嵰嶐嶐庠嵀

© 庐庀嶐幰 庀嶐巠崀 20

嵀巠崠嵐崰:

1. public class Comparisons { 2. public static void Main() { 3. 4. // int (Value-Type) comparison: 5. int i=1, j=1; 6. Console.WriteLine(" 1. {0}=={1}? {2}", i, j, i==j); 7. // same as: 8. Console.WriteLine(" 2. {0}.Equals({1})? {2}", 9. i, j, i.Equals(j)); 10. 11. // string (Reference-Type) comparison, 12. // but it's a special type: 13. string s1="string", s2="string"; 14. Console.WriteLine(" 3. {0}=={1}? {2}", s1, s2, s1==s2); 15. Console.WriteLine(" 4. {0}.Equals({1})? {2}", 16. s1, s2, s1.Equals(s2)); 17. 18. // StringBuilder (Reference-Type) comparison, 19. // but it's still a special type: 20. StringBuilder sb1 = new StringBuilder("SB"); 21. StringBuilder sb2 = new StringBuilder("SB"); 22. Console.WriteLine(" 5. {0}=={1}? {2}", 23. sb1, sb2, sb1==sb2); 24. Console.WriteLine(" 6. {0}.Equals({1})? {2}", 25. sb1, sb2, sb1.Equals(sb2)); 26. 27. // let's try a user defined Reference-Type comparison 28. Comparisons c1 = new Comparisons(); 29. Comparisons c2 = new Comparisons(); 30. Console.WriteLine(" 7. {0}=={1}? {2}", c1, c2, c1==c2); 31. Console.WriteLine(" 8. {0}.Equals({1})? {2}", 32. c1, c2, c1.Equals(c2)); 33. 34. // but on the other hand: 35. c2 = c1; 36. Console.WriteLine(" 9. {0}=={1}? {2}", c1, c2, c1==c2); 37. Console.WriteLine("10. {0}.Equals({1})? {2}", 38. c1, c2, c1.Equals(c2)); 39. 40. // let's see what happens if c2 is null: 41. c2 = null; 42. Console.WriteLine("11. {0}=={1}? {2}", c1, c2, c1==c2); 43. Console.WriteLine("12. {0}.Equals({1})? {2}", 44. c1, c2, c1.Equals(c2)); 45. 46. // now both are null: 47. c1 = c2; 48. Console.WriteLine("13. {0}=={1}? {2}", c1, c2, c1==c2); 49. // next line will throw an exception: 50. Console.WriteLine("14. {0}.Equals({1})? {2}", 51. c1, c2, c1.Equals(c2)); 52. } 53. }

.NET 庠幀庐嵐 C# 嶐帀庠庐巠 嶠庀帠 嶐帀庠庐巠嵐 庠嵐帐嵰嶐嶐庠嵀

© 庐庀嶐幰 庀嶐巠崀 21

崀嵐嵀 庠嶐帀嶰嵐庠嵀 巀庐 嶀巀幀嵀: 1. 1==1? True 2. 1.Equals(1)? True 3. string==string? True 4. string.Equals(string)? True 5. SB==SB? False 6. SB.Equals(SB)? True 7. Comparisons==Comparisons? False 8. Comparisons.Equals(Comparisons)? False 9. Comparisons==Comparisons? True 10. Comparisons.Equals(Comparisons)? True 11. Comparisons==? False 12. Comparisons.Equals()? False 13. ==? True Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object. at Comparisons.Main() in comparisons.cs:line 56

嵀庀帠嵀: 嶀幰嶐嶐崐嵐崀 嵐庠嵐崀 庐巠巠 巐嵀 巐嶐帀庠庐巠 嶐帀庐 巐崀嵀 庀庀崐巀 庐庀崰帀嵐 嵀崰嶐巠崐) 庠崀嵐嵐庐嵀References (

庠嶐嶀嶀帐嵀 嵀崰嵐庠巠崐 庐巠庠庐嵀巀 幐巀巠嵐巠Object.ReferenceEquals ,嵐崐帠庠庐 巀嶰巀 嵀嵀嵠 巰幀嵐崀崐 崰巐嶐崠嵐帐嵀 , 巀巀嵐嶰Value-Types嵐 -Reference-Types 庠崀 庐崰嵰巠 嵐庐巠嶐巠庐 Equals嵐 / 嵐崀

庀嵐嶀庀幀嵐崀 庠崀 嵐帐嶐巠帠嵀.==

嵀幰庠帠嵀– Value-Types 庠巠嵐帠巀 Reference-Types

巀庐 嵀巠庐嵀Value-Types 巀庐 嵀巠庐嵀庐 崰嵐帠崐 嵐巠幠帠 嶠庀帠嵀 庠崀 嵀幰嶐庠帠巠 Reference-Type 嵀 庠崀 嵀幰嶐庠帠巠-Reference 庠庀幠嵐嶐嵐 崰崐巀崐 嶀幰嶐嶐崐嵐崀 嵐庠嵐崀巀 庠幀帐嵐帀 嵀帠崐幠嵀.

崐 嵀巠庐嵀 庀嵐嶀庀幀嵐崀 庠崀 帐嶐巠帠嵀巀 巰庠嶐帀 崀巀-C#. 嵀幰巀嵰巠嵀 巐崠string) 崠嵐帐巠 崀嶐嵀庐Reference-Type (巀嶐帠巀 巐嶐巀巀嶰巀 嵀帀嵐帠 , 庀崐崰嵀庐 庠嵐庀巠巀巀崐巀崐巠 嵀崀庀帀.

巐嶐崐庠嵐嶰 嵐帀嵰帀崀 庀庐崀嶰: string str1 = "Hello"; string str2 = str1; str2 += " world";

庠嵠嵐庀嵰巠嵀 幰庀str2 嵀帀庠庐巠 )str1 庠庀崀庐帀 "Hello.(" 嵀庀嵐崀嶰巀 , 巀庐 嵀巠庐嵀嵀str1巀 -str2 庠嵐帐嵰嶐嶐庠嵀 庠巠庐嵀 崀巀嵐 嶠庀帠 庠巠庐嵀 嵀帀嶐嵀 ) 嵐帀嶐帀嶐庐庐 嵀崰崐嵐帠 庠崀 幰庀str2 .(!–巰嵐嶰帀 崀巀 嵀嵠 巀崐崀 . 嵀巀嵐帠幀嵀 巀帠嵐幀崐 += 巰嶐崐 嵀崰嶐庀幀嵀庐 嵐嵠 崀嶐嵀str2巀 -str1

庀嵐崐帠 嵀庐崰嵰 庠嵠嵐庀嵰巠 嵀庐帠巠巀 嵀庀幠嶐嵐str2) 嵀帀嵐嶰巠庐 嵀巀嵐帠幀"Copy on Write.(" 嵀幰巀嵰巠嵀string巠嶐巠 庀嵐嶀庀幀嵐崀 庠帐巠帠嵀 庠嵐帠幠巠崀崐 嵐嵠 嵀巀嵐帠幀 嵀庐) +崐 巰庠嶐帀 崀巀-C# 帐嶐巠帠嵀巀

庀嵐嶀庀幀嵐崀 庠崀+= , 庀嵐嶀庀幀嵐崀 庠帐巠帠嵀 巀崐崀 + 巀庐 嵀崰嵐崐帠嵀 庠庀嵐幠 庠崀 庠帠崐嵐幰.(+=

.NET 庠幀庐嵐 C# 嶐帀庠庐巠 嶠庀帠 嶐帀庠庐巠嵐 庠嵐帐嵰嶐嶐庠嵀

© 庐庀嶐幰 庀嶐巠崀 22

嵀崀崐嵀 嵀巠崠嵐崰嵀 庠嵐帠幠巠崀崐 嵐帀嶐庠嵐帀帠嶀 庠崀 嵰嶐嶰嵐帀:

1. class StringManipulation { 2. static public void Main() { 3. 4. string str1 = "Hello"; 5. string str2 = str1; 6. string str3 = str2; 7. 8. // check instance equality 9. Console.WriteLine("str1 and str2 are the same instance: 10. {0}", object.ReferenceEquals(str1, str2)); 11. Console.WriteLine("str2 and str3 are the same instance: 12. {0}", object.ReferenceEquals(str2, str3)); 13. Console.WriteLine("str1 and str3 are the same instance: 14. {0}", object.ReferenceEquals(str1, str3)); 15. 16. // append " world" to str2 17. str2 += " world"; 18. Console.WriteLine("str1: {0}", str1); 19. Console.WriteLine("str2: {0}", str2); 20. Console.WriteLine("str3: {0}", str3); 21. 22. // check instance equality again 23. Console.WriteLine("str1 and str2 are the same instance: 24. {0}", object.ReferenceEquals(str1, str2)); 25. Console.WriteLine("str2 and str3 are the same instance: 26. {0}", object.ReferenceEquals(str2, str3)); 27. Console.WriteLine("str1 and str3 are the same instance: 28. {0}", object.ReferenceEquals(str1, str3)); 29. } 30. }

崀嵐嵀 庠嶐帀嶰嵐庠嵀 巀庐 嶀巀幀嵀:

str1 and str2 are the same instance: True str2 and str3 are the same instance: True str1 and str3 are the same instance: True str1: Hello str2: Hello world str3: Hello str1 and str2 are the same instance: False str2 and str3 are the same instance: False str1 and str3 are the same instance: True

Clone

巀庐 嵀幰庠帠嵀崐 嶠嵐巠庠巀 巐嶐幠嵐庀 庀庐崀嶰Reference-Type庐巠巠巀 崠嵐嵀帀 巐庐崐 嵀崰嵐庠巠 Clone 庐嵐巠嶐巠 巀帠 嵠嶐庀嶰嵀巀嵐Interface 巐庐崐 ICloneable .崐 庠嵐崐庀 庠嵐幰巀嵰巠-Class Library 巰嶰崀 庠嶐嶐幠幰帀嵐幀 庠嵐幀庐嵐嵰Clone , 庠嶐嶐幠幰帀嵐幀 崐嵐庠嶰巀 嶠嶐崀 崰巠巀帀 嵐帀嵰帀崀Clone嶠庐巠嵀崐 .

.NET 庠幀庐嵐 C# 嶐帀庠庐巠 嶠庀帠 嶐帀庠庐巠嵐 庠嵐帐嵰嶐嶐庠嵀

© 庐庀嶐幰 庀嶐巠崀 23

Boxing嵐 -Unboxing

Value-Types 崠嵐帐巠 嵀帀庠庐巠嶰 巐庠嵐崀 嵐巀崐幰嶐庐 庠嵐嶐幠幰帀嵐幀巀 嵰巀庐嶐嵀巀 巐嶐巀嵐嶰嶐 object 庀嵐庠崐 嵐崀 Interface) 巀帠Interfaces嶠庐巠嵀崐 崰巠巀帀 ,庐 幰庀 巐嶐嶐庠帀嶐崐 庀巠崀帀-Value-Types 巐嶐巀嵐嶰嶐

庐巠巠巀Interface .( 崠嵐帐巠 嵀帀庠庐巠 巰嶰巀Value-Type 嵀帀庠庐巠巀 嵐巠幠帠 庠崀 庠嵐巠崰巀 庠帠崰巀 嶠嶐庀幠 崠嵐帐巠Reference-Type . 嵐嵠嵀 嵀庀巠嵀嵀 庠巀嵐帠幀–巠 -Value-Type巀 -Reference-Type –

庠崀庀幰帀Boxing , 庠崀庀幰帀 嵀嶰嵐幀嵀嵀 嵀庀巠嵀嵀Unboxing.

嵀巠崠嵐崰: )嵐帀崰巠巀 崀巀 崰嵐帠庐 巐嶐崀庐嵐帀 庠巀巀嵐嶰 嵀巠崠嵐崰嵀 ,嵀 巰嵐嶐帠庀 庠崀 巰嶐崐嵀巀 崀嶐嵀 嵀庀嶀巠嵀 巀崐崀-Boxing(.

1. public class BoxingUnboxing { 2. static public void Main() 3. { 4. A a = new A(); 5. Console.WriteLine("In Main, before DoIt1, a: " + a); 6. // in the next line 'a' is doing a "Boxing" 7. DoIt1(a); 8. Console.WriteLine("In Main, after DoIt1, a: " + a); 9. } 10. static public void DoIt1(ISetable a) 11. { 12. DoIt2(a); 13. Console.WriteLine("In DoIt1, after DoIt2, a: " + a); 14. DoIt3((A)a); // "Unboxing" (usually check before!) 15. Console.WriteLine("In DoIt1, after DoIt3, a: " + a); 16. } 17. static public void DoIt2(ISetable a) 18. { 19. a.Set(7); 20. } 21. static public void DoIt3(A a) 22. { 23. a.Set(15); 24. } 25. } 26. public interface ISetable { 27. void Set(int i); 28. } 29. 30. public struct A: ISetable 31. { 32. int i; 33. public void Set(int i) 34. { 35. this.i = i; 36. } 37. public override string ToString() 38. { 39. return "i = " + i; 40. } 41. }

.NET 庠幀庐嵐 C# 嶐帀庠庐巠 嶠庀帠 嶐帀庠庐巠嵐 庠嵐帐嵰嶐嶐庠嵀

© 庐庀嶐幰 庀嶐巠崀 24

崀嵐嵀 庠嶐帀嶰嵐庠嵀 巀庐 嶀巀幀嵀: In Main, before DoIt1, a: i = 0 In DoIt1, after DoIt2, a: i = 7 In DoIt1, after DoIt3, a: i = 7 In Main, after DoIt1, a: i = 0

嵀幀 嵀庀幰 嵀巠? 1. 崀嶐庀幰崐 嵀嶐幠幰帀嵐幀巀 嵀DoIt1 嵀帀庠庐巠嵀 a 庀崐帠 Boxing 嵀嶐幠幰帀嵐幀崐 嵐嶐巀崀 庠嵐帐嵰嶐嶐庠嵀嵀嵐 DoIt1

嵀帀庠庐巠 巀崀嶰 崀嶐嵀Reference , 嵀嶐幠幰帀嵐幀崐 嶠庀帠嵀 嶐嵐帀嶐庐 巰嶰巀DoIt2巀 巐崠 帰幰庠 -DoIt1. 2. 嵀嶐幠幰帀嵐幀嵀DoIt3 嶠庀帠 嵀帀庐巠 巀崐幰巀 嵀幠嵐庀 ) 崠嵐帐巠A( ,嵀 帠嵐幠嶐崐崐-casting巀 -A 嵐帀嵰帀崀

巐嶐帠幠崐巠 嵀庐帠巠巀Unboxing嵐 -a巀 嶠庀帠 嵀帀庠庐巠嶰 嵰巀庐帀 -DoIt3) 嵀-casting 帠幠嵐崐巠 庐 巐嶐帠崰嵐嶐 嵐帀嵰帀崀 嶐嶰 嵀幰嶐崰崐 崀巀巀-a 崠嵐帐巠 庠巠崀崐 崀嵐嵀 A ,嶠庀崰崐 巀崐崀- 巰崀嶰 庠庐庀崰帀 巀巀嶰

嵀幰嶐崰崐 .(崐 嶠庀帠嵀 嶐嵐帀嶐庐-DoIt3 巀帠 帠嶐幀庐巠 嵐帀帀嶐崀 DoIt1. 3. 巀帠 巀帠嵐幀崐 巐嶐帠嶐幀庐巠 巐帀嶐崀 巐嶐嶐嵐帀嶐庐嵀 巀嶰a崐 崐庐嵐嶐庐 -Main 嵀帀庠庐巠嵀 巀帠嵐幀崐庐 巰嵐嶐嶰 a 崀嵐嵀

崠嵐帐巠Value-Type) 嵀-Type嶰 庀崰崠嵐嵀 嵐巀庐 -struct.(

嵀 庠巀嵐帠幀-Garbage-Collector) GC( 嵀-CLR崐 庐巠庠庐巠 嵐帀帀嶐崀 -Reference Counting 嶐帀庠庐巠 巀嵐嵀嶐帀 嶠庀嵐幠巀 Reference

庠嵐崀崐嵀 庠嵐崐嶐帐嵀巠: • 庠嵐巀嶐帠嶐 庠嶐嶐帠崐– Reference Counting 巰嵐庀嶰帀嶐帐 庐庀嵐崰 Threads. • 庠嵐嶐巀崠帠巠 庠嶐嶐帠崐– Reference Counting 庠嵐帐嵰嶐嶐庠嵀 巐帠 崐嵐嶀 巰幀嵐崀崐 崰崰嵐巠庠嵀巀 帠崰嵐嶐 崀巀

庠嶐巀崠帠巠. 嵀-CLR崐 巐嶐嶐幰庐 嵀嵠巀 嵀巠嵐崰 巰嵐帀崠帀巠崐 庐巠庠庐巠 -JVM 巀庐 Java :Garbage Collector. 嵀-Garbage Collector) GC (崀崐嵀 巰幀嵐崀崐 崰崐嵐帠 :崐 嶐庠庀崰嶐帐 巰幀嵐崀崐-Thread 巐帠 Prioirity

崐 巐嶐崐庐嵐嶐庐 巐嶐嶀幰嶐嶐崐嵐崀嵀 巀嶰 巐嶐帀嵰崐帀 嶠嵐巠帀-heap ,嵀-GC 巐嶐嶀幰嶐嶐崐嵐崀 幰庀嵐 嶠崀 巰嵐庀嶰嶐嵠崐 庀嶐崀庐嶐 庠嵐帐嵰嶐嶐庠嵀 巐庀嵐崐帠 庠巠嶐嶐幰庐)嶐嶐庠嵀 巀巀嵐嶰嵀幀嶐幰帠 庠嵐帐嵰 (崐 嵀帀庠庐巠巠-stack嶐嶀嶀帐 嵀帀庠庐巠巠 嵐崀 .

嵐嵠嶰 庠嵐帐嵰嶐嶐庠嵀 巐庀嵐崐帠 巰嶐崀庐 巐嶐帀庠庐巠–嵐庀庀嵰嵐庐嶐 . 巀帠- 巐嶐巠嶐嶐幰庐 帰崀destructors崐 -C# , 巀庐 嵐庠巀帠幀嵀 嶐嵐庠嶐帠destructor嶐嵐嵠嶐嵰巀 巰庠嶐帀 嶐庠巀崐 崀嵐嵀 .嵀-destructor庀庀嵰庠庐嶐 嶀幰嶐嶐崐嵐崀嵀庐嶰 巀帠幀嵐嶐 ,嵀 庀庐崀嶰 幰庀 嵀庀幰嶐 嵀嵠 嶠崀-GC 崐嵐崐嶐帐 嵀庐帠嶐

巰嵐庀嶰嶐嵠崐 .巀帠幀嵀 庀崰帐 巀庐 巐庠destructor-巐嶐帠帀 崀巀 崐幠巠 庀幠嵐嵐嶐嵀巀 巀嵐嶰嶐嵐 嵰嶀崐嵐巠 嵐帀嶐崀 崀嵐嵀 巐崠 巐嶐 , 庀庐崀嶰destructor 庠崀 巀嶐帠幀嵀 庀崐嶰 庀嵰崀嵀 嶀幰嶐嶐崐嵐崀嵀庐 嵀巀崠嶐 庀嵰崀 嶀幰嶐嶐崐嵐崀 巐帠 庀崐崰巀 庀嵐巠崀庐

嵀-destructor嵀庠嶐崐嵀 嶠巀嵀嵐 嵐巀庐 . 巐庐崐 嵀嶐幠幰帀嵐幀 庐巠巠巀 崠嵐嵀帀 嵐嵠 嵀崐嶐帐巠Dispose 嶠庀嵐幠巀 巰嵐庀嶰嶐嵠 嶐崐崀庐巠 巐帀嶐崀庐 巐嶐崐崀庐巠 庀嵐庀嵰嶐庐)巀庐巠巀 :DB Connections ,巐嶐幠崐幰 , 嶐崐崀庐巠

Windows嵐嶰嵐 ' .( 嶠嶐庀幠 庐巠庠庐巠嵀巀 崀嵐庀幰巀 庀嵐嶰嵠巀-Dispose嵀嵠嶰 崐幠巠崐 , 嶀幰嶐嶐崐嵐崀嵀 庀庐崀嶰巀嶐帠幀 嵐帀帀嶐崀 庀崐嶰 嵐庠帀嶐嵰崐巠 .巀帠 幰嵠嵰嵐巠庐 巰嵐庀嶰嶐嵠嵀-巀帠 嶠庐巠嵀崐 庀庀嵰嵐庐嶐 嶀幰嶐嶐崐嵐崀嵀 嶐崰嶐-嵀 嶐崰嶐-GC.

嵀巠 庐幰崐巀 巰庠嶐帀-GC 庠嶐嶀嶀帐嵀 嵀嶐幠幰帀嵐幀巀 嵀崀嶐庀幰 庠嵐帠幠巠崀崐 巰嵐庀嶰嶐嵠崐 嶐崰嶐嶐巠嵐 巐嵐嵠嶐 崐嵐崐嶐帐

GC.Collect) 嵀庐 巰嵐嶐嶰巠 庠崀嵠 庠嵐庐帠巀 嵀崐嶐帐 巰嶐崀 巀巀嶰 嶠庀崰崐-GC 嵐巠幠帠 庠崀 巀嶐帠幀嵀巀 崰崐巀 帠崰嵐嶐 巰嵐庀嶰嶐嵠崐 庀嵐帐嵰巠 嵐帀庐嶐 庀庐崀嶰.(

巐嵐嵠嶐 巰幀嵐崀崐 嶐幀嶐幠幀帐 嶀幰嶐嶐崐嵐崀 巀庐 庀嵐庀嵰嶐庐巀 巐嵐庀崠巀 巰庠嶐帀 崀巀)巀帠 崀巀 巐崠- 庠巠庐嵀 嶐崰嶐null.(

.NET 庠幀庐嵐 C# 嶐帀庠庐巠 嶠庀帠 嶐帀庠庐巠嵐 庠嵐帐嵰嶐嶐庠嵀

© 庐庀嶐幰 庀嶐巠崀 25

嵀庀帠嵀 :VB 6 庠嵐帠幠巠崀崐 巰嵐庀嶰嶐嵠嵀 庠崀 巀嵀嶐帀 Reference Counting 嵐庀嶰嵠嵐嵀庐 庠嵐嶐帠崐嵀巠 巀崐帐嵐 嶐帠巀巀 , 巀庐 嵀巠庐嵀 帠幠崐巀 嵀嶐嵀 巰庠嶐帀 嶠崰嶐崀巠Nothing 嶀幰嶐嶐崐嵐崀巀 ) 巀庐 嵀巀嶐崐幰巠嵀VB巀 -null (

崰崰嵐崐 嶀幰嶐嶐崐嵐崀 巀庐 嶐崰嶐嶐巠 庀嵐庀嵰嶐庐 嶠庀嵐幠巀.

巐嶐庀嶀帀嶐嵐幀 嶐崐崠巀 嵀巠嵐?

嶐帀庠庐巠Reference崐 帰嶐巀嵰庠嵀 嵀庐帠巠巀 巐嵀 -C#巐嶐庀嶀帀嶐嵐幀巀 . 巠嶰 巐嶐庀嶀帀嶐嵐幀 巐帠 庠嵐庐帠巀 巰庠嶐帀庐 庠嵐帀嶰嵐帐巠 庠嵐巀嵐帠幀 帠幠崐巀 庀庐幀崀巠 崀巀 崀嵐嵀庐 巰嵐嶐嶰 崐嵐嶀 帰嶐巀嵰庠 嵐嵀嵠 嵐

巰嵐庀嶰嶐嵠崐 嶐庐幀嵐嵰 嶀嵐嶀嶐庐 ++)崰嶰嵐'( , 帠嵐幠嶐崐casting崰嵐帠嵐 庠嵐嵰幀嵐 庀庠嵐嶐 巐嶐帀嶰嵐帐巠 . 帰帐嵐帀崐 ,嵐帀庀嶰嵠嵀 庀崐嶰庐 嶐幀嶰 ,嵀-CLR崐 嵀幠幰嵐嵀庐 巰嵐庀嶰嶐嵠嵀 庠崀 嵐帀庀嵐崐帠 巀嵀帀巠 -heap 嶐帀庠庐巠 庀嵐崐帠

Reference庐庀崰帀 嵐帀帀嶐崀 庀崐嶰 嵀帀庠庐巠嵀 庀庐崀嶰 嵐庠嵐崀 庀庀嵰庐巀 崠崀嵐崰嵐 .

巀崐崀 ,庀嶀帀嶐嵐幀 嵐帀巀 庐庀崰帀 庠巠崀崐 巐嶐庠嶐帠巀 , 嵀庐嶐崠 嶠庀嵐幠巀 巀庐巠巀 巰嵐庀嶰嶐嵠崐 庠巠嶐嶐嵐帐巠 庠崐嵐庠嶰巀) 庠崐嵐庠嶰巀庐巠巀 嵀庀巠嵐嵰 崐嶐嶰庀 巀庐 庠嶐帐嶐幀( ,巀帠 帠幠嵐崐巠庐 嵀嵠巠 嵀帀嵐庐 巰幀嵐崀崐 巰嵐庀嶰嶐嵠 巀嵐嵀嶐帀 嶠庀嵐幠巀-嵀 嶐崰嶐-CLR

)庠嵐帀嵐庐 庠嵐崐嶐帐巠 ,巰嵐庀嶰嶐嵠 巀庐 巐嶐巀嵐崰崠 巐嶐幰嵐巀崐 巐帠 嵀崰嵐崐帠崐 庠嵐巀嶐帠嶐 庀幰嶐帠崐( , 崰嵐幰巀 嵀崀嶐庀幰 嶠庀嵐幠巀 嵐崀巀帠 巀嵀嵐帀巠 嵐帀帀嶐崀庐-嵀 嶐崰嶐-CLR 巐嶐庀嶀帀嶐嵐幀 嵐帀庠嶐崀巠 巀崐幰巀 巰嶐嶐帀嵐帠巠嵐 )崀嶐庀幰巀 嵀-dll-巐嶐嶐帀嵐幠嶐嵰 巐嶐.(

嵐巀崀嵀 巐嶐庀幰巠嵀 巀嶰 嶠庀嵐幠巀 ,巀帠 巰巠嵐帐巠庐 崰嵐幰 庠庀崠帐巠崐 巐嶐庀嶀帀嶐嵐幀 巐帠 崰嵐崐帠巀 庠庀庐幀崀巠 嵀幀庐嵀- 嶐崰嶐 嵀庀嵐巠庐嵀 嵀巀嶐巠嵀unsafe . 嶐帀庠庐巠 庀嶐巠嵀巀 巰庠嶐帀Reference庀嶀帀嶐嵐幀巀 ,嵀 帠嶀幰崐-unsafe.

嵀嵠 崀庐嵐帀崐 崐嶐嵰庀帀 崀巀 ,崐 嵀崀嶐庀幰崐 嵐巀嶐嵰庠嶐 幰嶐巠帠嵀巀 巐嶐帀嶐嶐帀嵐帠巠嵀-Help 巀帠 unsafe keyword.

.NET 庠幀庐嵐 C# 巐嶐巀嶐崠庀庠

© 庐庀嶐幰 庀嶐巠崀 26

嶐巀嶐崠庀庠巐

巀嶐崠庀庠1 庐巠庠庐巠嵀巠 巐嶐巠巀庐嵐 巐嶐嶐崐嵐嶐嵰 巐嶐庀幀帐巠 庠嶀巀嵐幰庐 庠嶐帀嶰嵐庠 崐嵐庠嶰) 庀幀帐巠嵀1-嶀巀幰嵀 庠崀 巐嶐嶐帐巠 ,

嶐幰嵐嵰 嶀巀幰巀 嵀帀嶐庠巠巠 庠嶐帀嶰嵐庠嵀嵐 嶐幰嵐嵰 崀巀嶰 庐巠庠庐巠巀 嵰嵐嵐崰巠 嶐幰嵐嵰 崀巀 嶀巀幰 庠崀嵠 庠巠嵐帠巀.( 嶀巀幰帀庐 嶐巀巠嶐帐幰巠嵀 庀幀帐巠嵀 庠崀 帐嶐幀崰庠 庠嶐帀嶰嵐庠嵀 嶀巀幰嵀 巐嵐嶐帐崐 ,嶐巀巠嶐帀嶐巠嵀 庀幀帐巠嵀 , 庠嵐巠嶰

帠幠嵐巠巠嵀嵐 嵀嶀巀幰帀庐 巐嶐庀幀帐巠嵀 . 巐嶐庐 嶠巀嵀巠崐 巐巠幠帠 巐嶐庀幀帐巠嵀 庠崀 庀嵐巠庐巀 嶠庀嵐幠 巰嶐崀庐 崐巀嶀巀幰嵀.

巀嶐崠庀庠2

巐嵀庐巀嶰 巐嶐嶐巀巠嶐幠崰 巐嶐庀幀帐巠 庐巠庠庐巠嵀巠 庠嶀巀嵐幰庐 庠嶐帀嶰嵐庠 崐嵐庠嶰)巐嶐嶐巀嶐巀庐 嵐崀 巐嶐嶐崐嵐嶐嵰 , 巐嶐庀崐庐巐嶐巠巀庐 嵐崀 .( 嵀巀嶐巠嵀quit) 嵀巀嵐崰崠 嵐崀 嵀帀嶀幰 庠嵐崀崐 ( 庠嵐崀嵀 嵐崀q) 嵀巀嵐崰崠 嵐崀 嵀帀嶀幰 ( 庠崀 庠嵐巠嶐嶐帐巠

嶀巀幰嵀 ,崀巀嶰 庐巠庠庐巠巀 嵰嵐嵐崰巠 嶐幰嵐嵰 崀巀 嶀巀幰 庠崀嵠 庠巠嵐帠巀嶐幰嵐嵰 嶀巀幰巀 嵀帀嶐庠巠巠 庠嶐帀嶰嵐庠嵀嵐 嶐幰嵐嵰 . 帐幀崀巀 庀庠嵐嶐崐 崐嵐庀幰嵀 庀幀帐巠嵀 庠崀 帐嶐幀崰庠 庠嶐帀嶰嵐庠嵀 嶀巀幰嵀 巐嵐嶐帐崐)嶐崐嵐嶐嵰 嵐崀 嶐巀嶐巀庐.(

巀嶐崠庀庠3

崀崐嵀 巰幀嵐崀崐 庠嵐嶐崐嶰嵐嶰 巀庐 巰嶐嶐嵐帠巠 嶠帐巠巀 嵀帐嶐幀崰巠庐 庠嶐帀嶰嵐庠 崐嵐庠嶰: *

*** ***** *** *

巰崐嵐巠嶰 , 嵐嵠 庠嶐帀嶰嵐庠 帠幠崐巀 巐嶐嶰庀崰 庀幀帐巠 巰帀庐嶐– 庐崀庀巠 巰嶐嶰嵀巀 庀庐幀崀 巀庐巠巀 5 嵀帐幀崰嵀 庠嵐庀嵐庐

庠嵐巠嶐崀庠巠 ,庠嶐帀嶰嵐庠嵀 巀嶰崐 崰崐巀崐 庠嵰崀 嵀帐幀崰嵀 庠庀嵐庐 巀嶐嶰嵀巀 嶠嶐庀幠 庐幰嵐崐巠嵀 巰嵐庀庠幀嵀.

巀嶐崠庀庠4 嵀帀嵐庐崀庀嵀 巐嶐帀嶐嶐嵐帠巠嵀 庠嶐帀嶰嵐庠 嵐巠嶰 崰嵐崐帠庠庐 庠嶐帀嶰嵐庠 崐嵐庠嶰 , 巰嶐嶐嵐帠巠嵀 嵀崐嵐崠 庠崀 巀崐幰庠 嶠崀

庐巠庠庐巠嵀巠 嶀巀幰嶰 庐幰嵐崐巠嵀.

巀嶐崠庀庠5 庀幀帐巠 庐巠庠庐巠嵀巠 庠巀崐幰巠庐 庠嶐帀嶰嵐庠 崐嵐庠嶰 ,嵐崰 嶠庀帠巠 嵀幠幰巠-嵐庠嵐崀 庠帐巀嶰崀巠嵐 嶐崰巠巠 嵰嵐巀崐

巀幀嶰嵀 . 崠嵐帐巠 嶠庀帠巠崐 庐巠庠庐嵀], [ 嶠庀帠巠崐 崀巀嵐.[][] 嶠庀帠嵀 庠崀 庀嶐嵠嵰庠嵐 嵀崰嵐巠帠 庀幀帐巠嵐 嵀庀嵐庐 庀幀帐巠 庐巠庠庐巠嵀巠 巀崐幰庠 庠嶐帀嶰嵐庠嵀 嶐帀庐嵀 崐巀庐崐

嶠庀帠巠嵀 嶠嵐庠巠 巐嶐崀庠巠嵀– 嵰嵐嵐嶀崐 巐帀嶐崀 嵐崀 庀幀帐巠 巐帀嶐崀庐 嵀崰嵐巠帠 嵐崀 嵀庀嵐庐 庀幀帐巠 庠嶀嶐巀幰巀 崰帠 巐嶐崀庠巠嵀 巐嶐庀幀帐巠嵀.

巀嶐崠庀庠6

嵐庀嵐庐嵀 庀幀帐巠 庠崀 庐巠庠庐巠嵀巠 庠嶀巀嵐幰庐 庠嶐帀嶰嵐庠 崐嵐庠嶰嵐崰 嶠庀帠巠崐 庠- 嵀庀嵐庐 巀嶰 庀嵐崐帠 嵠崀嵐 嶐崰巠巠巐巠幠帠 巐嶐庀崐嶐崀嵀 庠崀嵐 嵀庀嵐庐崐 巐嶐庀崐嶐崀嵀 庀幀帐巠 庠崀 庠嶀巀嵐幰.

嵀庀嵐庐 庀幀帐巠 庐巠庠庐巠嵀巠 巀崐幰庠 庠嶐帀嶰嵐庠嵀 嶐帀庐嵀 崐巀庐崐 , 嵀庀嵐庐崐 巐嶐庀崐嶐崀嵀 庀幀帐巠 庠崀 嵐巀 庀嶐嶰嵠庠嵐嵠 ,嶠庀帠巠嵀 嶠嵐庠巠 巐嶐崀庠巠嵀 嶠庀帠嵀 庠崀 帐嶐幀崰庠嵐 嵀崰嵐巠帠 庀幀帐巠 嶀嵐巀幰庠 嵠崀 . 巐嶐嶐帐庠 庠嶐帀嶰嵐庠嵀

巐帀嶐崀庐 嵀崰嵐巠帠 嵐崀 嵀庀嵐庐 庀幀帐巠 巀庐 嶀巀幰崐巐嶐崀庠巠嵀 巐嶐庀幀帐巠嵀 嵰嵐嵐嶀崐 巐帀嶐崀 嵐崀 庀幀帐巠 .

.NET 庠幀庐嵐 C# 巐嶐巀嶐崠庀庠

© 庐庀嶐幰 庀嶐巠崀 27

巀嶐崠庀庠7 嵀帠幀嵐嵀嵀 庠嵐嵰嶐嶰庐 巀庐 帰庀崠 嶠帐巠巀 嵀帐嶐幀崰巠 嵠崀嵐 庐巠庠庐巠嵀巠 庠嵠嵐庀嵰巠 庠嶀巀嵐幰庐 庠嶐帀嶰嵐庠 崐嵐庠嶰

嶀巀幰嵀 庠嵠嵐庀嵰巠崐 庠嵐崀 巀嶰 巀庐 .庠嵠嵐庀嵰巠崐 嵐帠嶐幀嵐嵀庐 庠嵐嶐庠嵐崀 幰庀嵐 嶠崀 巀嶐嶰嶐 帰庀崠嵀 , 庠嵐帐嵰嶐嶐庠嵀 嶠嵐庠嵀帀嶀幰嵐 嵀巀嵐崰崠 庠嵐崀巀 嵀嵀嵠 . 帰庀崠嵀 庠崠幠嵀 庠庀嵐幠–庠嵐崰嵐巠帠 嵐崀 庠嵐庀嵐庐 , 帠崐幰嶐庠帠 崀嶐嵀 巐崠" 嶀巀幰 嶐

庐巠庠庐巠嵀巠. 嵀巠崠嵐崰:

庠嵠嵐庀嵰巠嵀Hello Lolo庠嵐庀嵐庐 帰庀崠崐 : e # h # l #### o ###

庠嵠嵐庀嵰巠嵀Hello Lolo庠嵐崰嵐巠帠 帰庀崠崐 :

# # # # # # # # # e h l o