Tốt hơn là nên khai báo một biến bên trong hay bên ngoài một vòng lặp?

Question

là làm tốt hơn:

variable1Type foo; 
variable2Type baa; 

foreach(var val in list) 
{ 
    foo = new Foo(...); 
    foo.x = FormatValue(val); 

    baa = new Baa(); 
    baa.main = foo; 
    baa.Do(); 
} 

Hoặc:

foreach(var val in list) 
{ 
    variable1Type foo = new Foo(...); 
    foo.x = FormatValue(val); 

    variable2Type baa = new Baa(); 
    baa.main = foo; 
    baa.Do(); 
} 

Câu hỏi đặt ra là: 1 trường hợp hoặc 2 trường hợp là gì nhanh hơn? Sự khác biệt là không đáng kể? Nó có giống nhau trong các ứng dụng thực tế không? Đây có thể là một tối ưu hóa vi mô, nhưng tôi thực sự muốn biết cái nào tốt hơn.

Answer 1

Performance-khôn ngoan, chúng ta hãy thử ví dụ cụ thể:

public void Method1() 
{ 
    foreach(int i in Enumerable.Range(0, 10)) 
    { 
    int x = i * i; 
    StringBuilder sb = new StringBuilder(); 
    sb.Append(x); 
    Console.WriteLine(sb); 
    } 
} 
public void Method2() 
{ 
    int x; 
    StringBuilder sb; 
    foreach(int i in Enumerable.Range(0, 10)) 
    { 
    x = i * i; 
    sb = new StringBuilder(); 
    sb.Append(x); 
    Console.WriteLine(sb); 
    } 
} 

tôi cố tình chọn cả một giá trị kiểu và một tham chiếu kiểu trong trường hợp có ảnh hưởng đến mọi thứ. Bây giờ, IL cho họ:

.method public hidebysig instance void Method1() cil managed 
{ 
    .maxstack 2 
    .locals init (
     [0] int32 i, 
     [1] int32 x, 
     [2] class [mscorlib]System.Text.StringBuilder sb, 
     [3] class [mscorlib]System.Collections.Generic.IEnumerator`1<int32> enumerator) 
    L_0000: ldc.i4.0 
    L_0001: ldc.i4.s 10 
    L_0003: call class [mscorlib]System.Collections.Generic.IEnumerable`1<int32> [System.Core]System.Linq.Enumerable::Range(int32, int32) 
    L_0008: callvirt instance class [mscorlib]System.Collections.Generic.IEnumerator`1<!0> [mscorlib]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator() 
    L_000d: stloc.3 
    L_000e: br.s L_002f 
    L_0010: ldloc.3 
    L_0011: callvirt instance !0 [mscorlib]System.Collections.Generic.IEnumerator`1<int32>::get_Current() 
    L_0016: stloc.0 
    L_0017: ldloc.0 
    L_0018: ldloc.0 
    L_0019: mul 
    L_001a: stloc.1 
    L_001b: newobj instance void [mscorlib]System.Text.StringBuilder::.ctor() 
    L_0020: stloc.2 
    L_0021: ldloc.2 
    L_0022: ldloc.1 
    L_0023: callvirt instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(int32) 
    L_0028: pop 
    L_0029: ldloc.2 
    L_002a: call void [mscorlib]System.Console::WriteLine(object) 
    L_002f: ldloc.3 
    L_0030: callvirt instance bool [mscorlib]System.Collections.IEnumerator::MoveNext() 
    L_0035: brtrue.s L_0010 
    L_0037: leave.s L_0043 
    L_0039: ldloc.3 
    L_003a: brfalse.s L_0042 
    L_003c: ldloc.3 
    L_003d: callvirt instance void [mscorlib]System.IDisposable::Dispose() 
    L_0042: endfinally 
    L_0043: ret 
    .try L_000e to L_0039 finally handler L_0039 to L_0043 
} 

.method public hidebysig instance void Method2() cil managed 
{ 
    .maxstack 2 
    .locals init (
     [0] int32 x, 
     [1] class [mscorlib]System.Text.StringBuilder sb, 
     [2] int32 i, 
     [3] class [mscorlib]System.Collections.Generic.IEnumerator`1<int32> enumerator) 
    L_0000: ldc.i4.0 
    L_0001: ldc.i4.s 10 
    L_0003: call class [mscorlib]System.Collections.Generic.IEnumerable`1<int32> [System.Core]System.Linq.Enumerable::Range(int32, int32) 
    L_0008: callvirt instance class [mscorlib]System.Collections.Generic.IEnumerator`1<!0> [mscorlib]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator() 
    L_000d: stloc.3 
    L_000e: br.s L_002f 
    L_0010: ldloc.3 
    L_0011: callvirt instance !0 [mscorlib]System.Collections.Generic.IEnumerator`1<int32>::get_Current() 
    L_0016: stloc.2 
    L_0017: ldloc.2 
    L_0018: ldloc.2 
    L_0019: mul 
    L_001a: stloc.0 
    L_001b: newobj instance void [mscorlib]System.Text.StringBuilder::.ctor() 
    L_0020: stloc.1 
    L_0021: ldloc.1 
    L_0022: ldloc.0 
    L_0023: callvirt instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(int32) 
    L_0028: pop 
    L_0029: ldloc.1 
    L_002a: call void [mscorlib]System.Console::WriteLine(object) 
    L_002f: ldloc.3 
    L_0030: callvirt instance bool [mscorlib]System.Collections.IEnumerator::MoveNext() 
    L_0035: brtrue.s L_0010 
    L_0037: leave.s L_0043 
    L_0039: ldloc.3 
    L_003a: brfalse.s L_0042 
    L_003c: ldloc.3 
    L_003d: callvirt instance void [mscorlib]System.IDisposable::Dispose() 
    L_0042: endfinally 
    L_0043: ret 
    .try L_000e to L_0039 finally handler L_0039 to L_0043 
} 

Như bạn có thể thấy, ngoài các thứ tự trên stack trình biên dịch đã xảy ra để lựa chọn - có thể cũng giống như cũng đã là một thứ tự khác nhau - nó đã hoàn toàn không có hiệu lực. Đổi lại, có thực sự không phải là bất cứ điều gì mà một là cho jitter để sử dụng nhiều mà người khác không phải là cho nó.

Ngoài ra, có một sự khác biệt về loại.

Trong Method1() tôi, x và sb được scoped đến foreach, và không thể truy cập hoặc là cố tình hay vô tình bên ngoài của nó.

Trong tôi Method2(), x và sb không biết tại thời gian biên dịch được gán đáng tin cậy một giá trị trong foreach (trình biên dịch không biết foreach sẽ thực hiện ít nhất một vòng lặp), vì vậy sử dụng nó bị cấm .

Cho đến nay, không có sự khác biệt thực sự.

tôi thể tuy nhiên gán và sử dụng x và/hoặc sb ngoài foreach. Theo quy định, tôi có thể nói rằng đây có lẽ là phạm vi nghèo nàn hầu hết thời gian, vì vậy tôi ưu tiên Method1, nhưng tôi có thể có một số lý do hợp lý để đề cập đến chúng (thực tế hơn nếu chúng không được bỏ gán), trong trường hợp tôi muốn đi cho Method2.

Tuy nhiên, đó là vấn đề về cách mỗi mã có thể được mở rộng hay không, không phải là sự khác biệt của mã như được viết. Thực sự, không có sự khác biệt.

Answer 2

Nó không quan trọng, nó không ảnh hưởng đến hiệu suất.

nhưng tôi thực sự muốn biết làm đúng cách.

Hầu hết sẽ cho bạn biết bên trong vòng lặp có ý nghĩa nhất.

Answer 3

Đó chỉ là vấn đề về phạm vi. Trong trường hợp này, trong đó foo và trừu kêu chỉ được sử dụng trong vòng lặp for, cách tốt nhất là khai báo chúng bên trong vòng lặp. Nó cũng an toàn hơn.

Answer 4

Cả hai đều hoàn toàn hợp lệ, không chắc chắn có 'cách đúng' để thực hiện việc này.

Trường hợp đầu tiên của bạn hiệu quả về bộ nhớ hơn (ít nhất là trong thời gian ngắn). Khai báo các biến của bạn bên trong vòng lặp sẽ buộc tái phân bổ bộ nhớ nhiều hơn; tuy nhiên, với bộ thu gom rác .NETs, ​​vì các biến đó nằm ngoài phạm vi chúng sẽ được dọn dẹp định kỳ, nhưng không nhất thiết phải ngay lập tức. Sự khác biệt về tốc độ được cho là không đáng kể.

Trường hợp thứ hai thực sự an toàn hơn một chút, vì việc hạn chế phạm vi các biến của bạn càng nhiều càng tốt thì thường là thực hành tốt.

Answer 5

Trong JS phân bổ bộ nhớ là toàn bộ mỗi lần, Trong C#, không có sự khác biệt như vậy thường, nhưng nếu biến cục bộ được bắt bởi một phương thức nặc danh như biểu thức lambda thì nó sẽ quan trọng.

Answer 6

OK, tôi đã trả lời điều này mà không nhận thấy nơi áp phích ban đầu đang tạo đối tượng mới mỗi lần đi qua vòng lặp và không chỉ 'sử dụng' đối tượng. Vì vậy, không, không nên thực sự là một sự khác biệt không đáng kể khi nói đến hiệu suất. Với điều này, tôi sẽ đi với phương pháp thứ hai và khai báo đối tượng trong vòng lặp. Bằng cách đó, nó sẽ được dọn sạch trong lần truy cập GC tiếp theo và duy trì đối tượng trong phạm vi.

--- Tôi sẽ bỏ lại câu trả lời căn bản của mình, chỉ vì tôi đã nhập tất cả câu trả lời và nó có thể giúp người khác tìm kiếm thư này sau này. Tôi hứa rằng trong tương lai, tôi sẽ chú ý hơn trước khi tôi thử và trả lời câu hỏi tiếp theo.

Tim

Thực ra, tôi nghĩ có sự khác biệt. Nếu tôi nhớ chính xác, mỗi khi bạn tạo một đối tượng mới = new foo() bạn sẽ nhận được đối tượng đó được thêm vào bộ nhớ heap. Vì vậy, bằng cách tạo các đối tượng trong vòng lặp, bạn sẽ được thêm vào chi phí của hệ thống. Nếu bạn biết rằng vòng lặp sẽ nhỏ, nó không phải là một vấn đề.

Vì vậy, nếu bạn kết thúc bằng một vòng lặp với 1000 đối tượng trong đó, bạn sẽ tạo 1000 biến sẽ không được xử lý cho đến khi thu gom rác tiếp theo. Bây giờ nhấn vào một cơ sở dữ liệu nơi bạn muốn làm điều gì đó và bạn có 20.000 hàng để làm việc với ... Bạn có thể tạo ra một yêu cầu hệ thống tùy thuộc vào kiểu đối tượng bạn đang tạo.

Điều này sẽ dễ dàng kiểm tra ... Tạo ứng dụng tạo 10.000 mục có dấu thời gian khi bạn nhập vòng lặp và khi bạn thoát. Lần đầu tiên bạn làm điều đó, khai báo biến trước vòng lặp và lần tiếp theo trong vòng lặp. Bạn có thể phải tăng số lượng lên cao hơn 10K để thấy sự khác biệt thực sự về tốc độ.

Đồng thời, có vấn đề về phạm vi. Nếu được tạo trong vòng lặp, nó sẽ biến mất khi bạn thoát khỏi vòng lặp, do đó bạn không thể truy cập lại nó. Nhưng điều này cũng giúp với việc làm sạch như bộ sưu tập rác cuối cùng sẽ vứt bỏ nó một khi nó thoát khỏi vòng lặp.

Tim