bpl和dll文件的区别[翻译]

　　[原文]
　　
　　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。
　　
　　 但是我还是发现了一些不同，比如，
　　我可以在主应用程序中创建一个对象，把它传递给bpl，然后
　　我可以安全得修改它。但是如果我用dll的话，我就不能修改和
　　引用这个对象的属性。
　　

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

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

　　      如果你在exe和dll里使用同一个在stdctrls中定义的类，这两个类的vmt有不同的地址，is 和 as运算符在不同模块中不能正确地工作。 但是如果你使用包，那么内存中就只有一个类的拷贝，保存在vcl70.bpl中，那么所有引用那个包的模块会共享同一个类的定义。
　　      另一个因素就是system单元中内存管理器。所有的串分配最后都是调用getmem和freemem。如果exe分配了一个串，它使用它自己的getmem函数的拷贝，如果它把串传给dll，在dll中去free。那么这个dll会调用它自己的freemem函数的拷贝，而这个freemem函数不能访问exe中的内存管理器，这样就会产生错误。而如果用packages，它们都会使用rtl70.bpl中的内存管理器。（这个问题也可以通过在exe和dll间共享一个内存管理器来解决，共享内存只是个例子。但还是不能解决类之间的问题。）
　　

　　       综上述，我认为bpls和dlls之间的主要区别就是输出函数的数量。用dll输出的唯一的东西就是用exports关键字指定的那些。而用bpl，所有单元的interfaces里定义的都输出，包括全局变量和类定义，initialization和finalization部分的地址也输出。另外，在dll和bpl的内部，确实有很大的不同。bpl输出所有供RTI识别一个文件是bpl而不是dll文件所需的所有函数。如果你调用loadpackage，我也可以调用loadlibrary把它当作普通的dll来load，然后它会调用packages中所有单元的initializatin部分并做一些其他的housekeeping？的操作。调用包里的函数时产生的汇编代码和调用dll中函数产生的汇编代码是相同的。
　　
　　第一次翻译文章，很多地方翻译得不好。 
　　我觉得这篇文章很不错，希望有时间的高手能够重新翻译一次，谢谢。