Properties og exceptions

Følgende test:

  class Program {
    public void doStuff(PropertyClass p) {
      Console.WriteLine(p.FooProperty + " initial value of property");
      p.FooProperty = 1111;
      Console.WriteLine(p.FooProperty + " before exception");
      throw new Exception("Test Exception");
    }

    static void Main(string[] args) {
      PropertyClass p = new PropertyClass(8888);
      Program pgr = new Program();
      try {
        pgr.doStuff(p);
      } catch {
        Console.WriteLine("Exception caught");
      }
      Console.WriteLine(p.FooProperty + " after exception");
      Console.ReadKey();
    }
  }

  class PropertyClass {
    private int foo;

    public PropertyClass(int foo) {
      this.foo = foo;
    }

    public int FooProperty {
      get { return foo; }
      set { foo = value; }
    }
  }

Giver dette output:
8888 initial value of property
1111 before exception
Exception caught
1111 after exception

Så værdien af en property bevarer sin værdi efter en exception.

Ja, jeg har lavet lignende tests selv, men det jeg er ude efter er en mere teknisk forklaring af hvad der rent effektivt sker når der kastes en exception..

Så tror jeg du skal kigge lidt nærmere på:
http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-335.pdf

Afsnit "12.4.2.8 Control flow restrictions on protected blocks".


Når der kastes en exception sker der en ændring af control-flow i den tråd hvor exception kastes.

Sidste del af IL koden for doStuff metoden:
  IL_003d:  call      void [mscorlib]System.Console::WriteLine(string)
  IL_0042:  nop
  IL_0043:  ldstr      "Test Exception"
  IL_0048:  newobj    instance void [mscorlib]System.Exception::.ctor(string)
  IL_004d:  throw
// end of method Program::doStuff

Hvad der så sker der efter har jeg ikke læst, men jeg har en forventning om at det står i ovenstående nævnte afsnit. Det er bare ikke så let læseligt.

Kaldet til doStuff (med tilhørende try/catch) ser sådan ud:

  .try
  {
    IL_0012:  nop
    IL_0013:  ldloc.1
    IL_0014:  ldloc.0
    IL_0015:  callvirt  instance void TestExceptionVsProperty.Program::doStuff(class TestExceptionVsProperty.PropertyClass)
    IL_001a:  nop
    IL_001b:  nop
    IL_001c:  leave.s    IL_002e
  }  // end .try
  catch [mscorlib]System.Object
  {
    IL_001e:  pop
    IL_001f:  nop
    IL_0020:  ldstr      "Exception caught"
    IL_0025:  call      void [mscorlib]System.Console::WriteLine(string)
    IL_002a:  nop
    IL_002b:  nop
    IL_002c:  leave.s    IL_002e
  }  // end handler

Uden at være helt sikker så tror jeg det der sker er:

  1 newobj (som er af typen Exception) smides på stakken
  2 throw sørger for at control flow ændres
  3 catch blokken aktiveres (fordi det var en throw instruktion)
  4 pop henter Exception objektet, som så kan bruges hvis det deklareres i koden (har jeg ikke gjort).

F.eks noget ala:
try {
  pgr.doStuff(p);
} catch (Exception e) {
  Console.WriteLine(e.StackTrace());
}

Ok ja, det er jo straks mere teknisk ;-)

Jeg synes dog ikke det fremgår af ovenstående hvad der fysisk sker med det objekt der fremprovokerede en exception. Eller er det mig der ikke kan læse?

Altså hvad der, i eksemplet, sker med Program objektet (som doStuff er indeholdt i) ?

Der er i IL koden intet der antyder at der skulle ske noget, ud over de instruktioner som er udført.

Jeg tænker på hvad der sker med det objekt som i dit eksempel hedder PropertyClass, hvornår det bliver disposet, og hvorvidt properties og fields bliver disposet eller nulstillet eller hvad der sker..

Jeg kan ikke forestille mig at objektet bliver disposed på grund af exception.
Jeg referere jo til PropertyClass objektet efter at Exception er håndteret:
  Console.WriteLine(p.FooProperty + " after exception");

Tja, og jeg gør det både i min catch, og efter.. Nå, jeg kommer nok ikke nærmere lige nu. Smid et svar.

Ok.