使用可重用代码的最佳方式是什么？

Question

More often then not you will likely come across a situation where you may need a function or procedure, chances are you have already written this code before.

My question is how do you organise it so you dont have to rewrite everything, in other words what is the best way to maintain resuable code?

I was thinking of putting all my procedures and functions into one single unit, and adding this unit to the Uses clause of required forms etc.

But then the unit would become rather large, and so to use maybe one or two functions from the one large unit will add unnecessarily bulk size to the Application.

What I am basically asking is what is the best method for both performance and convenience wise, to manage, maintain and use reusable code?

UPDATE

Following some informative posts, I decided to proceed and use one single source unit that contains all my reusable routines. I have incorporated the use of the Delphi Code Editor's Code Folding to create custom regions, to seperate the different types into groups, well regions. All regions will be collapsed as well as having meaningful region names. I have added the single source unit to the Library path, which I can add to any forms uses clause and have access to all the reusable routines. See the screenshot for a better idea:

A lot more routines need adding in there. The regions help keep the code organized and easier to read, I can expand any if needed.

Thanks.

Answer 1

Instead of one unit, use a folder with multiple units.

Organise the units according to subject matter and strive to maintain high cohesion, low coupling. In other words: the units should contain functions and procedures that are closely related and use as few of your other units as possible (vcl/rtl can be freely used of course).

If you need inspiration on what kind of units you could have: I'd take a leaf out of the VCL and RTL. The way the units are organised and what stuff is put together versus what gets its own unit can give you a pretty clear understanding of how to organise your own stuff.

Answer 2

First, your assumption that large units result in large executables is wrong. Only the used parts get linked into the final executable.

Placing reusable routines in one or more separate units is common practice. To which extend you normalize this depends on your own proceedings or on imposed rules (eg by your company).

Personally, I like to name units like Delphi does: AwControls, AwUtils, AwDB, AwForms, AwMenus for those routines and classes that extend the default VCL or contain new or derived components. But I also create separate units for rather big components or for uncommon routines or classes like AwPlanGrid, AwDxf, AwIpTypes. Just a suggestion.

Another tip: Add the folder containing these units to your default project search path (to set in project options while having no project loaded in the IDE).

Answer 3

Today I tried to add a unit to my code, and it used another unit. That unit used three more. And the three that that one used, used a total of 27 other units.

Because those units weren't in a single folder, I had to set up a search path, or else add, a total of 27 units to my demo project, just so I could call one of my library functions.

In case you think this is extreme, just try to use SOME of the JEDI JCL or JVCL without using a lot more of it.

This is an example of the kind of coupling that makes it feel like it's Not Worth Trying to Reuse Your Code.

I am thinking that for my next project, instead of a monolithic dUnit for unit tests, that all tests for a single reusable chunk of the code should be built into their own separate executables, per class they test, and configured to explicitly include the units they need, without including any search folders/library folders that can allow new units to just silently be added to the code. Then I any time someone couples stuff, they would break the unit tests, and we would know something bad happened.

Anyways, that seems to me, to be one way to guarantee that your code avoids coupling, and that you could write a small or new application and pull into your code, just the pieces (components if you like) that you need, without a giant train of "USE-Clause-dependency hell".

Ditto to marjan's statement that a Single Unit is not the way to go; Dependencies in a huge Utility unit are going to go haywire. To build any project that uses that Utility unit, you will need to have available all the units in its interface and implementation section.

Keep it simple. Keep it separate. Coupling bad. easy and fun Reusability is only possible if you avoid coupling.

Answer 4

I put all my common code in a common library (actually there are about 4 PAS files in the same folder). Which is indeed huuuge. But only the needed code will be added to your exe, not the entire library. Delphi compiler is smart enough to know which code is needed.