Try-Catch のよくある質問

if $$$ISERR(sc) {
  throw ##class(%Exception.StatusException).CreateFromStatus(sc)
}

if SQLCODE<0 {
  throw ##class(%Exception.SQL).CreateFromSQLCODE(SQLCODE,%msg)
}

func(id) public {
  Try {
    ; Flag indicates if we locked the global
    Set locked=0
    ; If we cannot get the lock, throw a user-created 
    ; exception with the information we need
    Lock +^mygbl(id):0 If '$test {
      Throw ##class(Exception.MyException).%New("Unable to 
          lock",$name(^mygbl(id))) 
    }
    Set locked=1
    Set sc=$system.OBJ.Compile("MyClass")
    If $$$ISERR(sc) {
      Throw ##class(%Exception.StatusException).CreateFromStatus(sc)
    }
    ; Some further processing which may throw exceptions
    ; ...
        
    If locked { Lock -^mygbl(id) }    
  } 

Catch exception {
    ; Release the lock resource before doing anything else
    If locked { Lock -^mygbl(id) }
    ; First determine what sort of exception this is
    If exception.%IsA("%Exception.SystemException") {
      ; Log error in error log
      Do BACK^%ETN
      ; Throw my exception class rather than the system exception
      Throw ##class(Exception.MyException).CreateFromSystemException(exception)
    } ElseIf $classname(exception)="Exception.MyException" {
      ; Ignore this sort of exception and just return to code 
      ; after the catch block
    } Else {
      ; We will just throw these to outer error handler
      Throw exception
    }
  }
}

Class MyException.Status Extends %Exception.StatusException
{

  Property Stack [ MultiDimensional ];

  /// Convert a %Status into an exception
  ClassMethod CreateFromStatus(pSC As %Status)
      As %Exception.AbstractException
  {
    // You could choose to override %OnNew and put this code that
    // captures the stack there instead of here in CreateFromStatus.
    // We put it here because we only need to capture the stack in 
    // the outer exception, and it is more simply insulated from 
    // future changes in the superclasses.

    // First, call CreateFromStatus in the superclass to instantiate
    // the object and fill in the standard exception information.
    set exc=##super(pSC)

    // Clear $ecode so that $stack() refers to the current stack, 
    // not the error stack.
    set $ecode=""

    // Subtract one level because we don't need 
    // to see this method itself in the stack.
    set exc.Stack=$stack-1

    for i=1:1:exc.Stack {
      set exc.Stack(i)=$stack(i)_
          " "_$stack(i,"PLACE")_" "_$stack(i,"MCODE")
    }
    quit exc
  }
}

#include %occInclude
testexc(throwsystemexception) {
  try {
    do sub1($g(throwsystemexception)) 
  } catch exc {
    if exc.%IsA("%Exception.SystemException") {
      set stack=$stack(-1)
      // For System Exceptions, get the stack from the 
      // built-in error stack using $stack().
      for i=1:1:stack { 
        set stack(i)=$stack(i)_
            " "_$stack(i,"PLACE")_" "_$stack(i,"MCODE")
      }
    } else {
      if $extract($classname(exc),1,12)="MyException." {
        // Exceptions from package MyException will carry the
        // stack of the exception in the multidimensional
        // Stack property.
        merge stack=exc.Stack
      }
      // Set $ze explicitly because it's needed by BACK^%ETN
      // and only SystemExceptions set it implicitly. 
      set $ze=exc.DisplayString()
    }
    do BACK^%ETN
    write !,"Exception occurred: ",exc.DisplayString()
    write !,"  class: ",$classname(exc)
    write !,"  name: ",exc.Name
    write !,"  code: ",exc.Code
    if $data(stack) {
      write !,"  stack:"
      for i=1:1:stack {
        write !,"    ",stack(i)
      }
    }
    write !
  }
}
sub1(throwsystemexception) { 
  if throwsystemexception {
    do systemexception
  } else {
    do myexception
  }
}
myexception() PUBLIC {
  set sc=$$$ERROR($$$GeneralError,"this is my status code")
  throw ##class(MyException.Status).CreateFromStatus(sc)
}
systemexception() PUBLIC {
  // get a <DIVIDE> error
  set x=1\0 
}