Managing of shared resources between classes?

Imagine that I have a several Viewer component that are used for displaying text and they have few modes that user can switch (different font presets for viewing text/binary/hex). What would be the best approach for managing shared objects - for example fonts, find dialog, etc? I figured that static class with lazily initialized objects would be OK, but this might be the wrong idea.

static class ViewerStatic
{
    private static Font monospaceFont;
    public static Font MonospaceFont
    {
        get
        {
            if (monospaceFont == null)
                //TODO read font settings from configuration
                monospaceFont = new Font(FontFamily.GenericMonospace, 9, FontStyle.Bold);
            return monospaceFont;
        }
    }

    private static Font sansFont;
    public static Font SansFont
    {
        get
        {
            if (sansFont == null)
                //TODO read font settings from configuration
                sansFont = new Font(FontFamily.GenericSansSerif, 9, FontStyle.Bold);
            return sansFont;
        }开发者_开发问答
    }
}

For items you wish to create once and then re-use there are two relevant patterns: Singleton and Cache. If you will re-use the item forever, the Singleton is OK. The memory allocated to that instance will never be cleared. If you will re-use the item for a while, but then maybe that function won't be used for a few days, I suggest using the cache. Then the memory can be cleared when the item is no longer in use.

If you are using the Singleton, you probably want to just init the Fonts directly rather than using the Lazy init pattern. To me, Fonts sound pretty simple and not likely to error out. However, if the item might fail during construction (perhaps due to a missing font file or something), then lazy pattern at least allows it to retry next time. You cannot redo a static initializer later, even if it fails, without restarting the whole application. Be careful to limit those retries!

Finally, the name of your class "ViewerStatic" raises a concern. There is an anti-pattern known as the "God" object. I call it the "bucket". If you create it, stuff will come. You will soon find all kinds of stuff being dumped in the bucket. Your ViewerStatic class will become huge. It would be better to have a class called "FontFlyWeights" and then another one called "ConstantStrings" or "SystemDialogFactory" ... etc.

That seems fine to me, but is it really necessary? The simple approach would be to just create new fonts and dialogs when you need them, then Dispose them if necessary and let the garbage collector clean them up.

Have you measured to see if the simple approach has a noticeable cost that makes it worth adding the complexity of caching shared objects?