C#: přístup k Slovníku pomocí částečné třídy

Statická metoda FunctionA nelze získat přístup k instanci členů ClassA.

Buď změnit FunctionA aby být non-statické nebo mít slovník, pole statické.

Pořád nemůžu úplně říct, co se snažíte udělat. Ale budu dělat moje nejlepší, aby vám ukázat nějaké věci.

Beru tuto větu jste napsal: "konečným účelem je odhalit tento slovník a umožňují různé metody přímo číst/zapisovat z/do." jako můj průvodce

Částečné Třídy Problémů

Jak jsem již zmínil v komentářích: není tam žádná taková věc jako Částečné Třídy. Klíčové slovo částečné jednoduše označuje, že třída může být definována ve více než jeden soubor. Definice pravidla pro třídy zůstávají stejné, je to jen, že někteří členové třídy mohou být definovány v jednom souboru a další díly v jiných souborech.

O otázkách, které mají tu mít nic společného s partial klíčové slovo.

Své Dvě // Tohle nefunguje Poznámky

První z nich vypadá takto:

partial class ClassA
{
    ExampleDictionary instanceOfDict = new ExampleDictionary();
    instanceOfDict.Add(1, "Test1"); // This does not work
    //other code
}

První řádek deklaruje soukromé členské oblasti ClassA jménem instanceOfDict a inicializuje jej. To je důvod, proč se to zkompiluje.

Druhá linie se snaží dát spustitelný kód (volání funkce) přímo v horní části-rozsah na úrovni třídy. Můžete to udělat, že. Můžete si dát spoustu věcí na nejvyšší úrovni třídu (např., pole, vlastnosti, metody, delegáty, výčtové typy, vnitřní třídy), ale nemůžete dát tam kód.

Vaše druhá otázka vypadá takto:

public static void FunctionA()
{            
    for (int i = 0; i < 10; i++)
    {
        string text = $"Test{i}";
        instanceOfDict.Add(i, text); // This does not work as well              
    }          
}

Funk je static metoda. instanceOfDict je soukromé pole třídy, není deklarován statické. Nemůžete odkazovat na instance instance-level členy (metody, vlastnosti, pole, ...) z statické metody. Přečtěte si o static klíčové slovo.

Vytvoření Třídy, která Selektivně Odhaluje Slovník

Protože chcete udělat nějaké slovník práci uvnitř třídy, ale vystavit ho venku, tak jsem šel celé prase a udělal můj class generic na <TKey, TValue> tak, že pracuje se Slovníky jakéhokoliv typu.

Také jsem dělal to realizovat Sběr Inicializace Vzor , takže si můžete inicializovat instance své třídy, stejně jako to bylo slovníku.

Použít Kolekci Inicializace Vzor, vaše třídy musí udělat, aby věci:

1. Provedení IEnumerable nebo IEnumerable<T> (T může být jakéhokoliv typu, nejen typ sběr - můžete dokonce jen hodit NotImplementedException pokud vás nezajímá)

2. Patří metoda, která vypadá jako public void Add (SomeType atLeastOneParameter). Můžete mít více než jeden přetížení Add pokud chcete,.

Takže, začnu s tím (Všimněte si, že to implementuje IEnumerable<T>:

public partial class TestExposedDictionary<TKey, TValue> : IEnumerable<TValue>
{
    private readonly Dictionary<TKey, TValue> _theDictionary = new Dictionary<TKey, TValue>();

    public void Add(TKey key, TValue value)
    {
        _theDictionary.Add(key, value);
    }

    public IEnumerator<TValue> GetEnumerator()
    {
        foreach (var kvp in _theDictionary)
        {
            yield return kvp.Value;
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

To je dost, aby se třída většinou vypadají jako slovník (pravděpodobně chtít přidat některé způsob, jak získat data, atd. Ale, to je na vás (pravděpodobně budete chtít mít indexer (na TKey) a TryGetValue.

Ale, pojďme přidat nějaké další náhodné funkce třídy (dát to na horní úroveň rozsahu třídy):

    public int Count => _theDictionary.Count;

    public IEnumerable<KeyValuePair<TKey, TValue>> GetKeyValuePairs()
    {
        foreach (var kvp in _theDictionary)
        {
            yield return kvp;
        }
    }

To vám umožní vidět, jak mnoho věcí, které jsou ve vašem slovníku a umožní iterovat přes položky ( KeyValuePairs), že Slovník sbírky. Neváhejte přidat další funkce.

Konečně, na tento test...

public static void Test()
{
    var testDict = new TestExposedDictionary<int, string> {
        {1, "one" },
        {5, "five" },
        {8, "eight" },
        {10, "ten" },
        {105, "hundredFive" },
    };

    // I can call Add in the normal way as well:
    testDict.Add(300, "threeHundred");

    Console.WriteLine($"TestDict Count: {testDict.Count}");
    foreach (string s in testDict)
    {
        Console.WriteLine(s);
    }
}

Když jsem se spustit tento kód, který jsem dostal:

TestDict Count: 6
one
five
eight
ten
hundredFive
threeHundred

Toto rozdělení pomocí Částečné

Nevím, proč chcete použít partial class. Obvykle toto je děláno dva kousky kódu, které jsou upravené/udržována různými personas (typické důvod, proč je pro Visual Studio šablon/kouzelnickém mechanismus k udržení jedné straně partial class a programátor druhé.

Pravidla jsou velmi jednoduchá, stačí prohlásit public partial class MyClass ve dvou souborech. Oba soubory musí být ve stejném projektu (tj. sestaveny do stejné Sestavě) a třídy musí být ve stejném oboru názvů. Jakmile to uděláte, stačí rozdělit (top-level rozsah) bitů a kousky přes dva partial class prohlášení.

V těchto případech pravděpodobně bych se to rozdělit takhle:

• Jeden na jedné straně, tak jsem dal dvě funkce potřebné k provedení prohlásil IEnumerator<TValue>:
  • public IEnumerator<TValue> GetEnumerator()
  • IEnumerator IEnumerable.GetEnumerator()
• Na druhou stranu, já bych dal všechno ostatní:
  • Slovník prohlášení a intialization
  • Ostatní výčtu: public IEnumerable<KeyValuePair<TKey, TValue>> GetKeyValuePairs()
  • public int Count => _theDictionary.Count;
  • public void Add(TKey key, TValue value)