dotNETportal.cz

C# concept označovaný jako "class cluster" přímo nepodporuje. Jde to obejít tím, že konkrétní podtřídy jsou private a nested k hlavní abstraktní třídě (nebo jsou internal pokud to nevadí).

Je ale potřeba vhodně navrhnout nějakou factory, která určí, kdy která konkrétní třída vznikne. To bude záležet na konkrétním scénáři, např. může být do statické factory metody předáván název podtřídy.

Příklad:

public abstract class Animal
{
    private sealed class Giraffe : Animal
    {
    }

    private sealed class Tiger : Animal
    {
    }

    public static Animal CreateFromString(string animal)
    {
        string typeName = "Sample.Animal+" + animal;
        Type type = typeof(Animal).Assembly.GetType(typeName, true, true);

        var obj = (Animal)Activator.CreateInstance(type, true);
        return obj;
    }
}

var giraffe = Animal.CreateFromString("Giraffe");

Měl bych několik připomínek.

Za prvé, takto je Vám ta faktory metoda k ničemu, protože instanci Animal si nevytvoříte, abyste na ní poté mohl zavolat CreateFromString. Metoda samozřejmě musí být statická, ale řekl bych, že Vy to víte, jen jste to zapomněl napsat.

Za druhé, vnořené typy se nehledají přes tečkovou notaci, ale přes +. Zkuste si Vaší aplikaci spustit a podívat se, co vypíše

Assembly.GetExecutingAssembly().GetTypes()

a uvidíte

...
{Name = "Animal" FullName = "Sample.Animal"}
{Name = "Giraffe" FullName = "Sample.Animal+Giraffe"}
{Name = "Tiger" FullName = "Sample.Animal+Tiger"}
...

A za třetí, vnořené typy se používají v případě, když cítíte, že Vaše třída je zodpovědná za moc věcí a chcete jí trochu odlehčit, ale pořád se jedná o logiku privátní té dané třídě. Například pokud interně tvoříte složitou hierarchii dat a nechcete mít něco jako List<List<List>>, pak si vyvtoříte interní pomocné typy, které se chovají jako kolekce.

Možná jste jen zvolil špatný příklad, protože takto mi přijde přitažený za vlasy. Proč bych dělal konkrétní typy zvířat privátní a vnořené a jejich instance hledal pomocí reflexe? Tak jak je to napsané je jasné, že nové druhy zvířat budete přidávat Vy, protože pokud někdo jiný zdědí od Animal, stejně je mu ta factory metoda k ničemu. Takže třeba switch a nebo podle mě lepší statický Dictionary<string, Animal>.

Netuším, jakou definici pro class clusters používáte, já jsem si na netu našel pěkně hodnocenou následující

You want to provide a Factory (Cluster) interface that, with minimal description, manufactures and returns a specific concrete instance of a Factory Object that satisfies the behavior of the cluster family described by the Factory (Cluster) interface.

i s příkladem, který mě na private nested typy rozhodně nevede. Zdroj: http://stackoverflow.com/q/1844158/80900...

Tak pak je rozumný nápad vystavit pouze interface a konkrétní implementace mít privání či interní v dané assembly, tak nějak jak Tomáš vysvětluje definici vzoru. Tím máme vyřešenou stranu public API. Co se týče vnitřní logiky, která je známá pouze Vám, rozhodně bych se nevydal cestou zapouzdřených konkrétních tříd v abstraktní třídě, ale normálně interface : implementace. Abstraktní třída je abstraktní proto, že nemá vědět, jak je používaná. Má mít nějaké předpoklady a podle toho poskytovat členy na přepsání, ale nemá znát detaily o každé své implementaci.

Pokud třída účet nemá žádnou vlastní logiku, jen definuje služby, může to klidně být rozhraní. Pro účty to bude určitě abstraktní třída, protože každý účet má svoje číslo, atd. Ale ať je to jednodušší ...

public interface IUcet
{
    decimal Vybrat();
    void Ulozit(decimal castka);
    decimal Zustatek { get; }
}

Pak máme ty konkrétní implementace, které známe jenom my.

internal class BeznyUcet : IUcet
{
    public decimal Vybrat() { return 1; }
    public void Ulozit(decimal castka) { }
    public decimal Zustatek { get { return 0; } }
}

internal class SporiciUcet : IUcet
{
    public decimal Vybrat() { return 2; }
    public void Ulozit(decimal castka) { }
    public decimal Zustatek { get { return 0; } }
}

Pak statickou třídu na vytváření účtů, ať už veřejnou, nebo privátní, která obsahuje logiku pro zakládání nových účtů.

public static class TovarnaNaUcty
{
    public static IUcet ZalozitNovyUcet(string id)
    {
        if (id.StartsWith("ABC"))
            return new BeznyUcet();
	if (id.StartsWith("XYZ"))
	    return new SporiciUcet();
			
	throw new ArgumentException("Spatny kod uctu.");
    }	
}

A nakonec konzumenta tohoto API, který zná jenom rozhraní IUcet a případně má přístup k továrně, ale ani to nemusí být. Jeho nezajímají konkrétní typy účtů, jen potřebuje rozhraní pro výběr a uložení peněz.

IUcet ucet = TovarnaNaUcty.ZalozitNovyUcet("ABC123456789DEF");
decimal vybranePenizeNevimOdkud = ucet.Vybrat();

Souhlasíte? Máte něco podbného? Kde přesně je teď problém?