类别:Delphi 点击:0 评论:0 推荐:


That is correct. A BPL is a DLL. (But not all DLLs are BPLs.)

> But I still found some different, such as that I can create a
> object from the Host exe and that pass to a BPL and modify it safely, but
> if I do same to a dll, I can not modify any referenced property of the object.

When you use packages, there is only ever one copy of any unit in
memory. One copy of Forms, one copy of SysUtils, one copy of System
(well, most of it), one copy of StdCtrls, etc.

All class-related operations, such as the "is" and "as" operators, rely
on class references. Class references are actually just addresses. They
point to definitions for the layouts of the classes' internals. (They
point to what's called the virtual-method table, the VMT.) Two classes
are the same if they point to the same VMT -- if the addresses are equal.

When you have a class defined in the EXE's copy of StdCtrls and the same
class defined in a DLL's copy of StdCtrls, those classes will really
have different addresses. The "is" and "as" operators won't work with
cross-module clases. But when you use packages, there is only one copy
of the class, kept in vcl70.bpl, so all modules that reference that
package will share a single class definition.

Another factor is the memory manager in System. All string allocations
ultimately call GetMem and FreeMem. If the EXE allocates a string, it
uses its own GetMem. It then passes the string to a DLL, and the DLL
might try to free it. The DLL will call its own copy of FreeMem, which
won't have access to the EXE's memory-manager structures, and you'll get
errors. With packages, everything will use the same memory manager from
rtl70.bpl. (This can also be solved by using a shared memory manager
between the EXE and the DLL; ShareMem is one example. That won't solve
the class-comparison problem, though.)

Above, I said the major difference between BPLs and DLLs is the number
of exported functions. With a DLL, the only things exported are what
appear in the "exports" clause that you write yourself. With a BPL,
everything from all the units' "interface" sections gets exported,
including global variables and class definitions. Also exported are the
addresses of the "initialization" and "finalization" sections. And,
internally, that is indeed the major difference. A BPL exports the
functions necessary for the RTL to recognize the file as being a BPL and
not just a generic DLL. If you call LoadPackage, i will call LoadLibrary
to load it like a normal DLL, and then it will call all the package's
units' initialization sections and do a fe other housekeeping
operations. Calling a package's functions generates the same kind of
assembler code as is generated when you call a DLL function.


      是的, bpl是dll,  但不是所有dll都是bpl。

> 但是我还是发现了一些不同,比如,

      使用packages时 ,每个单元, 每个窗体, 每个sysutils, 每个system等等在内存中都只有一份拷贝,

所有作用于类的操作符 ,比如is和as ,都依赖于类的引用, 类的引用其实就是一个(受限的)指针,指向类的定义(就是虚函数表 vmt) 如果两个引用指向相同的vmt,那么它们就是同一个类的引用。

      如果你在exe和dll里使用同一个在stdctrls中定义的类,这两个类的vmt有不同的地址,is 和 as运算符在不同模块中不能正确地工作。 但是如果你使用包,那么内存中就只有一个类的拷贝,保存在vcl70.bpl中,那么所有引用那个包的模块会共享同一个类的定义。