http://delphi.about.com/od/objectpascalide/a/errorexception.htm

Unfortunately, building applications includes coding.

Regardless of how carefully you write/debug your program,

it will be impossible to imagine every situation that can go wrong.

Inexperienced user might, for example,

try to open a nonexisting file or input a bad value into a data field.

Users make mistakes and we should be prepared to handle/prevent these errors

wherever and whenever possible.

Errors, Exceptions?

An exception is generally an error condition or other event

that interrupts normal flow of execution in an application.

Whenever an error results from processing a line of code,

Delphi creates (raises) an object descendent from TObject called the exception object.

Guarded Blocks

An application responds to an exception either by executing some termination code,

handling the exception, or both.

The way to enable error/exception trapping within a given code,

the exception must occur within a guarded block of statements.

The general code looks like:

try
{guarded block of code}
except
on <ESomeException> do
begin
{exception block-handles SomeException}
end;
end;

A try / except statement executes the statements in the guarded block of code.

If the statements execute without any exceptions being raised,

the exception block is ignored, and control is passed to the statement following the end keyword.

Example:

Zero:=;
try
dummy:= / Zero;
except
on EZeroDivide do
MessageDlg('Can not divide by zero!', mtError, [mbOK], ) ;
end;

Protecting Resources

When a section of code acquires a resource, it is often necessary to ensure that the resource is released again

(or you might get a memory leak ), regardless of whether the code completes normally or is interrupted by an exception.

In this case, the syntax usesfinally keyword and looks like:

{some code to allocate resources}
try
{guarded block of code}
finally
{termination blok - code to free resources}
end; { Example } AboutBox:=TAboutBox.Create(nil) ;
try
AboutBox.ShowModal;
finally
AboutBox.Free;
end;

Application.OnException

If your application doesn't handle the error that caused the exception,

then Delphi will use its default exception handler - it will just pop up a message box.

You may consider writing code in the OnException event for TApplication object,

in order to trap errors at the application level.

Break On Exceptions

When building a program with exception handling,

you may not want Delphi to break on Exceptions.

This is a great feature if you want Delphi to show where an exception has occurred;

however, it can be annoying when you test your own exception handling.

On Handling Exceptions in Delphi Exception Handling

No code is error free!

Some code is full of "errors" on purpose :)

What's an error in an application? An error, from my general point of view,

is, for example, the wrongly coded solution to a problem.

Such are logic errors that could lead to wrong function results

where everything seems nicely but the result of the application is completely unusable (i.e. wrong).

With logic errors, application might or might not stop working.

An exception is an exceptional condition.

Exceptions include errors in your code where you try to divide numbers with zero,

or you try using freed memory blocks or you try providing wrong parameters to a function.

An exception in an application is not always an error -

if by error we think on those nasty problems with the program where it stop responding.

Exceptions And The Exception Class

As stated, exception are special conditions that require special handling.

When an error-type condition occurs the program raises an exception.

As suggested by Nick Hodges in Exception Handling for Fun and Profit article,

application writers should trap exceptions, exceptions get raised by components and library code on purpose.

You (as the application writer) handle exceptions, to make your application more error-prone,

to respond to the exceptional condition.

In most cases you will find yourself being the application writer and also the library writer.

So you would need to know how to raise exceptions (from your library) and how to handle them (from your application).

I'm sure we all have dozens of units defining some special-to-me classes, interfaces and alike.

For example, I have a class dealing with PDF documents I'm using in several of my applications.

When I code / edit the class I am the library writer, when I'm using the library I'm the application writer.

Let's take a look at handling exceptions...

The article Handling Errors and Exceptions provides some basic guidelines on

how to guard against errors using try/except/end and try/finally/end protected blocks to respond to or handle exceptional conditions.

A simple try/except guarding blocks looks like:

try
ThisFunctionMightRaiseAnException();
except
{ handle any exceptions raised in ThisFunctionMightRaiseAnException() here }
end;

The ThisFunctionMightRaiseAnException might have, in its implementation, a line of code like

raise Exception.Create('special condition!');

he Exception is a special class (one of a few without a T in front of the name) defined in sysutils.pas unit.

The SysUtils unit defines several special purpose Exception descendants

(and thus creates a hierarchy of exception classes )

like ERangeError, EDivByZero, EIntOverflow, etc.

In most cases the exceptions that you would handle in the protected try/except block

would not be of the Exception (base) class but of some special Exception descendant class defined i

n either the VCL or in the library (you or some other developer coded) you are using.

Handling Exceptions Using Try/Except

To catch and handle an exception type you would construct a "on type_of_exception do" exception handler.

The "on exception do" looks pretty much like the classic case statement :

try
ThisFunctionMightRaiseAnException;
except
on EZeroDivide do
begin
{ something when dividing by zero }
end;
on EIntOverflow do
begin
{ something when too large integer calculation }
end;
else
begin
{ something when other exception types are raised }
end;
end;

Note that the else part would grab all (other) exceptions,

including those you know nothing about.

In general, your code should handle only exceptions you actually know how to handle and expect to be thrown.

Also, you should never "eat" an exception:

try
ThisFunctionMightRaiseAnException;
except
end;

Eating the exception means you do not know how to handle the exception

or you do not want users to see the exception or anything in between.

When you handle the exception and you need more data from it

(after all it is an instance of a class) rather only the type of the exception you can do:

try
ThisFunctionMightRaiseAnException;
except
on E : Exception do
begin
ShowMessage(E.Message);
end;
end;

The "E" in "E:Exception" is a temporary exception variable of type specified

after the column character (in the above example the base Exception class).

Using E you can read (or write) values to the exception object, like get or set the Message property.

Who Frees The Exception?

Noticed how exceptions are actually instances of a class descending from Exception?

The raise keyword throws an exception class instance.

You know that what you create (the exception instance is an object) you also need to free .

If, you as a library writer, create an instance, will the application user free it?

Or, who will?

Delphi magic:

handling an exception automatically destroys the exception object.

This means that when you write the code in the "except / end" block - this block (hm, bad wording)

will release the exception memory.

So what happens if ThisFunctionMightRaiseAnException

actually raises an exception and you are not handling it

(this is not the same as "eating" it)?

How Come My App Does Not Crash When number/0 Is Not Handled?

When an unhandled exception is thrown in your code,

Delphi "magically" handles your exception by displaying the error dialog to the user.

In most cases this dialog will not provide enough data for the user (and finally you)

to understand the cause of the exception.

This is controlled by Delphi's top level message loop

where ALL exceptions are being processed

by the global Application object and its HandleException method.

To handle exceptions globally, and show your own more-user-friendly dialog,

you can write code for the TApplicationEvents.OnException event handler.

Note that the global Application object is defined in the Forms unit.

The TApplicationEvents is a component you can use to intercept the events of the global Application object.

Ok, that's it for now.

Next time I'll go into reraising exception.

Handling Errors and Exceptions的更多相关文章

  1. Python Tutorial 学习(八)--Errors and Exceptions

    Python Tutorial 学习(八)--Errors and Exceptions恢复 Errors and Exceptions 错误与异常 此前,我们还没有开始着眼于错误信息.不过如果你是一 ...

  2. 《The Python Tutorial》——Errors and Exceptions 阅读笔记

    Errors and Exceptions 官方文档:https://docs.python.org/3.5/tutorial/errors.html python中所有的异常都继承自BaseExce ...

  3. [译]The Python Tutorial#8. Errors and Exceptions

    [译]The Python Tutorial#Errors and Exceptions 到现在为止都没有过多介绍错误信息,但是已经在一些示例中使用过错误信息.Python至少有两种类型的错误:语法错 ...

  4. Laravel API Errors and Exceptions: How to Return Responses

    Laravel API Errors and Exceptions: How to Return Responses February 13, 2019 API-based projects are ...

  5. 笔记-python-tutorial-8.errors and exceptions

    笔记-python-tutorial-8.errors and exceptions 1.      errors and exceptions 1.1.    syntax errors >& ...

  6. STL之Errors and Exceptions

    Error Handling STL设计的目标是性能最优化,而不是最安全. 错误检查是极其浪费时间的,因此,STL对于错误处理几乎没有做处理,因此,这对STL的使用者的要求就非常高. 为什么不采取错误 ...

  7. python异常和错误(syntax errors 和 exceptions)

    语法错误 语法错误又被称解析错误 >>> for i in range(1..10):print(i) File "<stdin>", line 1 ...

  8. Python Errors and Exceptions

    1. python中的try{}catch{} 2. raise exception 3. try...except ... else.. 4. finally块 python中的异常处理的keywo ...

  9. Understanding Asynchronous IO With Python 3.4's Asyncio And Node.js

    [转自]http://sahandsaba.com/understanding-asyncio-node-js-python-3-4.html Introduction I spent this su ...

随机推荐

  1. UVALive 5760 Alice and Bob

    题意是黑板上有n个数\(S_i\).每次操作可以把其中一个数减1或者将两个数合并为一个数.一个数变为0时,则不能再对其操作. 思路是发现最大的可操作次数为\( \sum S_i\)+(n - 1).\ ...

  2. Docker Commands

    Docker Commands 安装,以Ubuntu 14.04.3为例 apt-get install docker.io 注意安装之前需要更新系统 列出曾经存在的容器 docker ps -a 列 ...

  3. shell脚本执行方式

    # BY THE WAY, 其实这块内容算是比较简单的,但是都比较常记得它最基本的两种方式,另外两种却忘记了 1. 利用sh或bash命令执行 sh test.sh bash test.sh 2. 在 ...

  4. 配置Tomcat、maven远程部署调试总结。

    注意:可以搞两个环境,一个本地tomcat 一个服务器上的tomcat ,然后都采用如下配置.这样就可以 在本地调试,调试好后,再发布到服务器端.非常方便.  ==================== ...

  5. python和C语言的差别

    之前在公司一直做的是C语言的开发,然后做的都是业务方面的东西,做的是sdk,因为最近在找工作,然后今天面试的时候被问到C语言和Python的区别,自己只是简单的说了C是静态语言,在变量在使用前进行声明 ...

  6. python基础(5)---整型、字符串、列表、元组、字典内置方法和文件操作介绍

    对于python而言,一切事物都是对象,对象是基于类创建的,对象继承了类的属性,方法等特性 1.int 首先,我们来查看下int包含了哪些函数 # python3.x dir(int) # ['__a ...

  7. python开发学习-day10(select/poll/epoll回顾、redis、rabbitmq-pika)

    s12-20160319-day10 *:first-child { margin-top: 0 !important; } body>*:last-child { margin-bottom: ...

  8. Deepin 2015 火狐 Firefox安装Flash

    1.sudo apt-get install flashplugin-nonfree 2.至Abobe官网下载最新的Linux版本flash安装包,选择.tar.gz类型,下载(https://get ...

  9. Knockout介绍

    Knockout.js是什么? Knockout是一款很优秀的JavaScript库,它可以帮助你仅使用一个清晰整洁的底层数据模型(data model)即可创建一个富文本且具有良好的显示和编辑功能的 ...

  10. Java 大小写转换

    Java 大小写转换 public class CaseConversion { /** * @param character: a character * @return: a character ...