5*/catch *kullanma hakkında soru try/catch/finallybol gördük. Vetry/finally özellikle using deyimi uygulanan biçimi olduğu için kesinlikle bir senaryo olduğunu biliyorum.

Ayrıca the overhead of try/catch and exceptions ile ilgili sorular gördük.

Ben bağlantılı soru, ancak, SADECE deneyin sonunda kalmadan yükü hakkında konuşmaz.

Farz yok özel bir şey olur try blok, ne yükü olduğundan emin olun finally get ifadeleri yürütülen bırakmak try blok (bazen geri döndürme işlevi)?

Yine, SADECE 16*/finally*hayır catch özel durumlar falan soruyorum.

Teşekkürler!

DÜZENLEME:Tamam, kullanın benim durum biraz daha iyi göstermeye çalışacağım.

Olan, DoWithTryFinally DoWithoutTryFinally kullanmalıyım?

public bool DoWithTryFinally()
{
  this.IsBusy = true;

  try
  {
    if (DoLongCheckThatWillNotThrowException())
    {
      this.DebugLogSuccess();
      return true;
    }
    else
    {
      this.ErrorLogFailure();
      return false;
    }
  }
  finally
  {
    this.IsBusy = false;
  }
}

public bool DoWithoutTryFinally()
{
  this.IsBusy = true;

  if (DoLongCheckThatWillNotThrowException())
  {
    this.DebugLogSuccess();

    this.IsBusy = false;
    return true;
  }
  else
  {
    this.ErrorLogFailure();

    this.IsBusy = false;
    return false;
  }
}

Bu dava sadece iki dönüş noktası vardır, çünkü aşırı basit, ama eğer dört...... veya On veya yüz olsaydı çok daha küçüktü.

Bir noktada aşağıdaki nedenlerletry/finally kullanmak isterdim:

• KURU ilkelerine özellikle çıkış noktası sayısı yükseldikçe ()
• Eğer içimdeki işlevi bir istisna değil atma hakkında yanıldığım ortaya çıkarsa, o zaman this.Working 25* *ayarlandığından emin olmak istiyorum.

Varsayımsal olarak, belirli . ben^>performans sorunları, sürdürülebilirlik, ve KURU prensiplerihangi numarayı çıkış noktaları ben. (özellikle için ben^>olabilirtüm iç özel durum yakalandı varsayalım) 26*/finally*ile ilişkili uğramak istemiyorum?

EDİT #2:this.IsBusy this.Working adını değiştirdim. Üzgünüm, bu sadece bir iş parçacığı daha önce böyle bir yöntemi olsa) birden çok iş parçacığı olduğunu söylemeyi unutmuşum; başka bir iş parçacığı nesnenin işi olup olmadığını görmek için yoklama olacak. Dönüş değeri sadece işe giderse beklendiği gibi başarı ya da başarısızlık.

Neden aslında ne bak değil mi?

Burada C kodu basit bir parça#:

    static void Main(string[] args)
    {
        int i = 0;
        try
        {
            i = 1;
            Console.WriteLine(i);
            return;
        }
        finally
        {
            Console.WriteLine("finally.");
        }
    }

Ve burada hata ayıklama yapı içinde ortaya çıkan IL:

.method private hidebysig static void Main(string[] args) cil managed
{
    .entrypoint
    .maxstack 1
    .locals init ([0] int32 i)
    L_0000: nop 
    L_0001: ldc.i4.0 
    L_0002: stloc.0 
    L_0003: nop 
    L_0004: ldc.i4.1 
    L_0005: stloc.0 
    L_0006: ldloc.0 // here's the WriteLine of i 
    L_0007: call void [mscorlib]System.Console::WriteLine(int32)
    L_000c: nop 
    L_000d: leave.s L_001d // this is the flavor of branch that triggers finally
    L_000f: nop 
    L_0010: ldstr "finally."
    L_0015: call void [mscorlib]System.Console::WriteLine(string)
    L_001a: nop 
    L_001b: nop 
    L_001c: endfinally 
    L_001d: nop 
    L_001e: ret 
    .try L_0003 to L_000f finally handler L_000f to L_001d
}

ve burada hata ayıklama çalışırken Meclisi JİT tarafından üretilen:

00000000  push        ebp 
00000001  mov         ebp,esp 
00000003  push        edi 
00000004  push        esi 
00000005  push        ebx 
00000006  sub         esp,34h 
00000009  mov         esi,ecx 
0000000b  lea         edi,[ebp-38h] 
0000000e  mov         ecx,0Bh 
00000013  xor         eax,eax 
00000015  rep stos    dword ptr es:[edi] 
00000017  mov         ecx,esi 
00000019  xor         eax,eax 
0000001b  mov         dword ptr [ebp-1Ch],eax 
0000001e  mov         dword ptr [ebp-3Ch],ecx 
00000021  cmp         dword ptr ds:[00288D34h],0 
00000028  je          0000002F 
0000002a  call        59439E21 
0000002f  xor         edx,edx 
00000031  mov         dword ptr [ebp-40h],edx 
00000034  nop 
        int i = 0;
00000035  xor         edx,edx 
00000037  mov         dword ptr [ebp-40h],edx 
        try
        {
0000003a  nop 
            i = 1;
0000003b  mov         dword ptr [ebp-40h],1 
            Console.WriteLine(i);
00000042  mov         ecx,dword ptr [ebp-40h] 
00000045  call        58DB2EA0 
0000004a  nop 
            return;
0000004b  nop 
0000004c  mov         dword ptr [ebp-20h],0 
00000053  mov         dword ptr [ebp-1Ch],0FCh 
0000005a  push        4E1584h 
0000005f  jmp         00000061 
        }
        finally
        {
00000061  nop 
            Console.WriteLine("finally.");
00000062  mov         ecx,dword ptr ds:[036E2088h] 
00000068  call        58DB2DB4 
0000006d  nop 
        }
0000006e  nop 
0000006f  pop         eax 
00000070  jmp         eax 
00000072  nop 
    }
00000073  nop 
00000074  lea         esp,[ebp-0Ch] 
00000077  pop         ebx 
00000078  pop         esi 
00000079  pop         edi 
0000007a  pop         ebp 
0000007b  ret 
0000007c  mov         dword ptr [ebp-1Ch],0 
00000083  jmp         00000072 

Ben denemek ve son olarak yorum ve dönüş yaparsa, JİT aynı Kurul alıyorum neredeyse. Göreceksin farkları finally bloğunun içine bir atlama ve nihayet sonra Nereye anlamak için biraz kod yürütülür. KÜÇÜK farklar hakkında konuşuyorsun. Serbest atlayış içine sonunda will sağlar out - parantez nop talimatları, bu yüzden bu duruma bir atlamak için bir sonraki talimat, olur da bir nop - bu kolay bir gözetleme deliği optimizasyonu. Pop ses ve hafıza yerinin bu tür benzer şekilde ucuz.

    {
00000000  push        ebp 
00000001  mov         ebp,esp 
00000003  push        edi 
00000004  push        esi 
00000005  push        ebx 
00000006  sub         esp,34h 
00000009  mov         esi,ecx 
0000000b  lea         edi,[ebp-38h] 
0000000e  mov         ecx,0Bh 
00000013  xor         eax,eax 
00000015  rep stos    dword ptr es:[edi] 
00000017  mov         ecx,esi 
00000019  xor         eax,eax 
0000001b  mov         dword ptr [ebp-1Ch],eax 
0000001e  mov         dword ptr [ebp-3Ch],ecx 
00000021  cmp         dword ptr ds:[00198D34h],0 
00000028  je          0000002F 
0000002a  call        59549E21 
0000002f  xor         edx,edx 
00000031  mov         dword ptr [ebp-40h],edx 
00000034  nop 
        int i = 0;
00000035  xor         edx,edx 
00000037  mov         dword ptr [ebp-40h],edx 
        //try
        //{
            i = 1;
0000003a  mov         dword ptr [ebp-40h],1 
            Console.WriteLine(i);
00000041  mov         ecx,dword ptr [ebp-40h] 
00000044  call        58EC2EA0 
00000049  nop 
        //    return;
        //}
        //finally
        //{
            Console.WriteLine("finally.");
0000004a  mov         ecx,dword ptr ds:[034C2088h] 
00000050  call        58EC2DB4 
00000055  nop 
        //}
    }
00000056  nop 
00000057  lea         esp,[ebp-0Ch] 
0000005a  pop         ebx 
0000005b  pop         esi 
0000005c  pop         edi 
0000005d  pop         ebp 
0000005e  ret 

/Sonunda denemek için çok, çok küçük maliyetler konuşuyorsun. Bu konularda çok az sorun alanları vardır. Eğer yaptığın bir şey gibi işlev, hedef'in ve koyun bir deneyin/sonunda her bayt olmak kopyalanan ve daha sonra devam etmek için kopya yüzlerce MB veri, görebildiğim kadarıyla bu bir sorun, ama en kullanımı? İhmal edilebilir.