Get And Sign 990 Schedule L Instructions Form

My $0.02 for what it’s worth:Your question pertains to any object oriented language supporting exceptions and some form of polymorphism, whether via interfaces or via (abstract) base classes, since as you imply, it would seem that the possible exceptions that may be thrown from an interface implementation should arguably form part of the interface contract.The trouble is that the definer of an interface cannot in the very general abstract case (which is what an interface or abstract class specification is about), possibly know all the kinds of unexpected problems (exceptions) every possible type of concrete implementation of a given interface that might be ever be created in the future may encounter and therefore need to raise. This is true both on the consumer and the producer side.That is, it’s in a sense impossible to pre-emptively define all the possible exceptions associated to every potential interface implementation, that is to be handled, ahead of time. (I suppose I could add: … unless you’re prepared to severely limit and constrain the implementors of your interface to only those cases that you’ve imagined and thought of, the trouble being that this is almost inevitably going to vastly reduce the usefulness of your interface as it will overspecify and bind your implementors vastly more strictly than you arguably ought.)At best, the definer of an interface could/should suggest (advisory) categories of exceptions that could or should be raised (and/or possibly handled by a client) in certain general situations for possible given anticipated implementations and or situations that are anticipated to be relevant during some implementations of an interface, again taking case not to make assumptions or impose unwarranted restrictions about unimagined possible uses and implementations not imagined yet.Of course enforcing or checking of this kind of “advisory” specification is not explicitly supported by C# (or really any other language that I can think of right now), while Java’s exception contracts while seemingly a good idea in principle and a step in this direction, is a bit too simplistic and too strict in practice, tending towards being overly burdensome and being somewhat problematic in many cases as also pointed out in Eric Worrall’s answer.