Objektum- és gyűjtemény inicializálók (C# programozási útmutató)

A C# lehetővé teszi egy objektum vagy gyűjtemény példányosítását és tag-hozzárendelések egyetlen utasításban történő végrehajtását.

Objektum-inicializálók

Az objektum inicializálói segítségével értékeket rendelhet egy objektum bármely akadálymentes mezőjéhez vagy tulajdonságához a létrehozáskor. Nem kell konstruktort meghívnia, majd hozzárendelési utasításokat használnia. Az objektum inicializáló szintaxisa lehetővé teszi, hogy argumentumokat adjon meg egy konstruktorhoz, vagy kihagyja az argumentumokat és zárójeleket. Az objektum-inicializálók konzisztens használatáról az Objektum inicializálók használata (stílusszabály IDE0017) című témakörben olvashat. Az alábbi példa bemutatja, hogyan használható egy objektum inicializáló nevesített típussal, Catés hogyan hívhatja meg a paraméter nélküli konstruktort. Vegye figyelembe az automatikusan implementált tulajdonságok használatát a Cat osztályban. További információ: Automatikusan implementált tulajdonságok.

public class Cat
{
    // Automatically implemented properties.
    public int Age { get; set; }
    public string? Name { get; set; }

    public Cat()
    {
    }

    public Cat(string name)
    {
        this.Name = name;
    }
}

Cat cat = new Cat { Age = 10, Name = "Fluffy" };
Cat sameCat = new Cat("Fluffy"){ Age = 10 };

Az objektum inicializáló szintaxisával létrehozhat egy példányt, és hozzárendelheti az újonnan létrehozott objektumot a hozzárendelt tulajdonságokkal együtt a hozzárendelés változóhoz.

Kezdve a beágyazott objektumtulajdonságokkal, az objektum inicializáló szintaxisa new kulcsszó nélkül is használható. Ez a szintaxis, Property = { ... }, lehetővé teszi a meglévő beágyazott objektumok tagjainak inicializálását, ami hasznos írható tulajdonságokkal. További információ: Objektum inicializálók osztálytípusú tulajdonságokkal.

Az objektum inicializálói a mezők és tulajdonságok hozzárendelése mellett indexelőket is beállíthatnak. Fontolja meg ezt az alapszintű Matrix osztályt:

public class Matrix
{
    private double[,] storage = new double[3, 3];

    public double this[int row, int column]
    {
        // The embedded array will throw out of range exceptions as appropriate.
        get { return storage[row, column]; }
        set { storage[row, column] = value; }
    }
}

Az identitásmátrix inicializálásához használja a következő kódot:

var identity = new Matrix
{
    [0, 0] = 1.0,
    [0, 1] = 0.0,
    [0, 2] = 0.0,

    [1, 0] = 0.0,
    [1, 1] = 1.0,
    [1, 2] = 0.0,

    [2, 0] = 0.0,
    [2, 1] = 0.0,
    [2, 2] = 1.0,
};

Bármely elérhető indexelő, amely tartalmaz egy elérhető beállítót, használható objektum inicializáló kifejezésként, függetlenül az argumentumok számától vagy típusától. Az indexargumentumok a hozzárendelés bal oldalát alkotják, az érték pedig a kifejezés jobb oldala. Például a következő inicializálók érvényesek, ha IndexersExample a megfelelő indexelőkkel rendelkezik:

var thing = new IndexersExample
{
    name = "object one",
    [1] = '1',
    [2] = '4',
    [3] = '9',
    Size = Math.PI,
    ['C',4] = "Middle C"
}

Az előző kód fordításához a IndexersExample típusnak a következő tagokat kell tartalmaznia:

public string name;
public double Size { set { ... }; }
public char this[int i] { set { ... }; }
public string this[char c, int i] { set { ... }; }

Névtelen típusok objektum-inicializálói

Bár bármilyen környezetben használhat objektum inicializálókat, ezek különösen hasznosak Language-Integrated Lekérdezés (LINQ) kifejezésekben. A lekérdezési kifejezések gyakran használnak névtelen típusokat, amelyeket csak objektum-inicializálóval inicializálhat, ahogyan az alábbi deklarációban is látható.

var pet = new { Age = 10, Name = "Fluffy" };

Névtelen típusok használatával a select LINQ-lekérdezési kifejezés záradéka átalakíthatja az eredeti sorozat objektumait olyan objektumokká, amelyek értéke és alakja eltér az eredetitől. Előfordulhat, hogy az egyes objektumok információinak csak egy részét szeretné sorozatban tárolni. A következő példában tegyük fel, hogy egy termékobjektum (p) számos mezőt és metódust tartalmaz, és csak a terméknevet és az egységárat tartalmazó objektumok sorozatát szeretné létrehozni.

var productInfos =
    from p in products
    select new { p.ProductName, p.UnitPrice };

A lekérdezés végrehajtásakor a productInfos változó olyan objektumok sorozatát tartalmazza, amelyek az alábbi példában látható módon érhetők el egy foreach utasításban:

foreach(var p in productInfos){...}

Az új névtelen típus minden objektuma két nyilvános tulajdonsággal rendelkezik, amelyek ugyanazokat a neveket kapják, mint az eredeti objektum tulajdonságai vagy mezői. Névtelen típus létrehozásakor is átnevezhet egy mezőt. Az alábbi példa átnevezi a mezőt a UnitPrice következőre Price: .

select new {p.ProductName, Price = p.UnitPrice};

Objektum-inicializálók a required módosítóval

required A kulcsszóval kényszerítheti a hívókat egy tulajdonság vagy mező értékének objektum inicializálóval való beállítására. Nem kell konstruktorparaméterként beállítania a szükséges tulajdonságokat. A fordító biztosítja, hogy az összes hívó inicializálja ezeket az értékeket.

public class Pet
{
    public required int Age;
    public string Name;
}

// `Age` field is necessary to be initialized.
// You don't need to initialize `Name` property
var pet = new Pet() { Age = 10};

// Compiler error:
// Error CS9035 Required member 'Pet.Age' must be set in the object initializer or attribute constructor.
// var pet = new Pet();

Ez egy tipikus gyakorlat, amely garantálja, hogy az objektum megfelelően inicializálva van, különösen akkor, ha több mezőt vagy tulajdonságot szeretne kezelni, és nem szeretné mindet belefoglalni a konstruktorba.

Objektum inicializálók a init tartozékkal

Egy tartozék használatával init meggyőződhet arról, hogy az objektum nem változik az inicializálást követően. Segít korlátozni a tulajdonságérték beállítását.

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; init; }
}

// The `LastName` property can be set only during initialization. It CAN'T be modified afterwards.
// The `FirstName` property can be modified after initialization.
var pet = new Person() { FirstName = "Joe", LastName = "Doe"};

// You can assign the FirstName property to a different value.
pet.FirstName = "Jane";

// Compiler error:
// Error CS8852  Init - only property or indexer 'Person.LastName' can only be assigned in an object initializer,
//               or on 'this' or 'base' in an instance constructor or an 'init' accessor.
// pet.LastName = "Kowalski";

A kötelező csak init-only tulajdonságok támogatják a nem módosítható struktúrákat, miközben lehetővé teszik a természetes szintaxist a típus felhasználói számára.

Osztálytípusú tulajdonságokkal rendelkező objektum-inicializálók

Amikor osztálytípusú tulajdonságokkal inicializál objektumokat, két különböző szintaxist használhat:

1. Objektum inicializáló kulcsszó nélkülnew:Property = { ... }
2. Objektum-inicializáló kulcsszóvalnew:Property = new() { ... }

Ezek a szintaxisok másképp viselkednek. Az alábbi példa mindkét megközelítést szemlélteti:

public class HowToClassTypedInitializer
{
    public class EmbeddedClassTypeA
    {
        public int I { get; set; }
        public bool B { get; set; }
        public string S { get; set; }
        public EmbeddedClassTypeB ClassB { get; set; }

        public override string ToString() => $"{I}|{B}|{S}|||{ClassB}";

        public EmbeddedClassTypeA()
        {
            Console.WriteLine($"Entering EmbeddedClassTypeA constructor. Values are: {this}");
            I = 3;
            B = true;
            S = "abc";
            ClassB = new() { BB = true, BI = 43 };
            Console.WriteLine($"Exiting EmbeddedClassTypeA constructor. Values are: {this})");
        }
    }

    public class EmbeddedClassTypeB
    {
        public int BI { get; set; }
        public bool BB { get; set; }
        public string BS { get; set; }

        public override string ToString() => $"{BI}|{BB}|{BS}";

        public EmbeddedClassTypeB()
        {
            Console.WriteLine($"Entering EmbeddedClassTypeB constructor. Values are: {this}");
            BI = 23;
            BB = false;
            BS = "BBBabc";
            Console.WriteLine($"Exiting EmbeddedClassTypeB constructor. Values are: {this})");
        }
    }

    public static void Main()
    {
        var a = new EmbeddedClassTypeA
        {
            I = 103,
            B = false,
            ClassB = { BI = 100003 }
        };
        Console.WriteLine($"After initializing EmbeddedClassTypeA: {a}");

        var a2 = new EmbeddedClassTypeA
        {
            I = 103,
            B = false,
            ClassB = new() { BI = 100003 } //New instance
        };
        Console.WriteLine($"After initializing EmbeddedClassTypeA a2: {a2}");
    }

    // Output:
    //Entering EmbeddedClassTypeA constructor Values are: 0|False||||
    //Entering EmbeddedClassTypeB constructor Values are: 0|False|
    //Exiting EmbeddedClassTypeB constructor Values are: 23|False|BBBabc)
    //Exiting EmbeddedClassTypeA constructor Values are: 3|True|abc|||43|True|BBBabc)
    //After initializing EmbeddedClassTypeA: 103|False|abc|||100003|True|BBBabc
    //Entering EmbeddedClassTypeA constructor Values are: 0|False||||
    //Entering EmbeddedClassTypeB constructor Values are: 0|False|
    //Exiting EmbeddedClassTypeB constructor Values are: 23|False|BBBabc)
    //Exiting EmbeddedClassTypeA constructor Values are: 3|True|abc|||43|True|BBBabc)
    //Entering EmbeddedClassTypeB constructor Values are: 0|False|
    //Exiting EmbeddedClassTypeB constructor Values are: 23|False|BBBabc)
    //After initializing EmbeddedClassTypeA a2: 103|False|abc|||100003|False|BBBabc
}

Főbb különbségek

• Kulcsszó nélkül new (ClassB = { BI = 100003 }): Ez a szintaxis módosítja az objektumkonstruktor által létrehozott tulajdonság meglévő példányát. Meghívja a meglévő objektum taginicializálóit.

• Kulcsszóval new (ClassB = new() { BI = 100003 }): Ez a szintaxis létrehoz egy új példányt, és hozzárendeli a tulajdonsághoz, lecserélve a meglévő példányokat.

Az inicializáló new nélkül újrahasználja az aktuális példányt. Az előző példában a ClassB értékei a következők: 100003 (új hozzárendelt érték), true (az EmbeddedClassTypeA inicializálásából megtartva), BBBabc (a EmbeddedClassTypeB alapértelmezett értéke változatlan).

Objektum inicializálói írásvédett tulajdonságok nélkül new

A new nélküli szintaxis hasznos az írásvédett tulajdonságokkal. Új példány nem rendelhető hozzá, de inicializálhatja a meglévő példány tagjait:

public class ReadOnlyPropertyExample
{
    public class Settings
    {
        public string Theme { get; set; } = "Light";
        public int FontSize { get; set; } = 12;
    }

    public class Application
    {
        public string Name { get; set; } = "";
        // This property is read-only - it can only be set during construction
        public Settings AppSettings { get; } = new();
    }

    public static void Example()
    {
        // You can still initialize the nested object's properties
        // even though AppSettings property has no setter
        var app = new Application
        {
            Name = "MyApp",
            AppSettings = { Theme = "Dark", FontSize = 14 }
        };

        // This would cause a compile error because AppSettings has no setter:
        // app.AppSettings = new Settings { Theme = "Dark", FontSize = 14 };

        Console.WriteLine($"App: {app.Name}, Theme: {app.AppSettings.Theme}, Font Size: {app.AppSettings.FontSize}");
    }
}

Ez a módszer lehetővé teszi a beágyazott objektumok inicializálását akkor is, ha a benne lévő tulajdonság nem rendelkezik beállítóval.

Gyűjtemény inicializálói

A gyűjtemény inicializálói lehetővé teszik, hogy egy vagy több elem inicializálóját megadjuk, amikor egy olyan gyűjteménytípust inicializálunk, amely implementálja a IEnumerable interfészt, és rendelkezik egy Add metódussal, amely a megfelelő aláírással rendelkező példánymetódusként vagy bővítménymetódusként szerepel. Az elem-inicializálók lehetnek értékek, kifejezések vagy objektum inicializálók. Gyűjtemény inicializáló használatával nem kell több hívást megadnia; a fordító automatikusan hozzáadja a hívásokat. A gyűjtemény inicializálóinak konzisztens használatáról a Gyűjtemény inicializálók használata (stílusszabály IDE0028) című témakörben talál útmutatást. A gyűjtemény inicializálói a LINQ-lekérdezésekben is hasznosak.

Az alábbi példa két egyszerű gyűjtemény inicializálót mutat be:

List<int> digits = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
List<int> digits2 = new List<int> { 0 + 1, 12 % 3, MakeInt() };

Az alábbi gyűjtemény inicializálója objektum-inicializálókkal inicializálja az Cat előző példában definiált osztály objektumait. Az egyes objektum inicializálók zárójelek közé vannak zárva, és vesszővel vannak elválasztva.

List<Cat> cats =
[
    new Cat { Name = "Sylvester", Age = 8 },
    new Cat { Name = "Whiskers", Age = 2 },
    new Cat { Name = "Sasha", Age = 14 }
];

Ha a gyűjtemény metódusa lehetővé teszi, null értéket adhat meg elemként a gyűjtemény inicializálójábanAdd.

List<Cat?> moreCats = new List<Cat?>
{
    new Cat{ Name = "Furrytail", Age=5 },
    new Cat{ Name = "Peaches", Age=4 },
    null
};

Használhat egy szórt elemet arra, hogy létrehozzon egy listát, amely más listát vagy listákat másol.

List<Cat> allCats = [.. cats, .. moreCats];

További elemeket is belefoglalva, a terjesztési elemet használva.

List<Cat> additionalCats = [.. cats, new Cat { Name = "Furrytail", Age = 5 }, .. moreCats];

Indexelt elemeket akkor adhat meg, ha a gyűjtemény támogatja az olvasási/írási indexelést.

var numbers = new Dictionary<int, string>
{
    [7] = "seven",
    [9] = "nine",
    [13] = "thirteen"
};

Az előző minta olyan kódot hoz létre, amely meghívja az Item[TKey]-t az értékek beállításához. A szótárakat és más asszociatív tárolókat az alábbi szintaxissal is inicializálhatja. Indexelő szintaxis helyett zárójelekkel és hozzárendeléssel egy több értékkel rendelkező objektumot használ:

var moreNumbers = new Dictionary<int, string>
{
    {19, "nineteen" },
    {23, "twenty-three" },
    {42, "forty-two" }
};

Ez az inicializáló példa meghívja Add(TKey, TValue) , hogy adja hozzá a három elemet a szótárhoz. Az asszociatív gyűjtemények inicializálásának két különböző módja kissé eltérő viselkedést eredményez a fordító által generált metódushívások miatt. Mindkét változat együttműködik az Dictionary osztálysal. Más típusok csak az egyiket vagy a másikat támogatják a nyilvános API-juk alapján.

Gyűjteménykifejezés argumentumai

A C# 15-től kezdve a with(...) első elemeként használja az elemet, hogy argumentumokat adjon át a gyűjtemény konstruktorának. Ezzel a funkcióval kapacitást, összehasonlítókat vagy más konstruktorparamétereket adhat meg közvetlenül a gyűjteménykifejezés szintaxisában:

public static void CollectionExpressionWithArgumentsExample()
{
    string[] values = ["one", "two", "three"];

    // Use with() to pass capacity to the List<T> constructor
    List<string> names = [with(capacity: values.Length * 2), .. values];

    Console.WriteLine($"Created List<string> with capacity: {names.Capacity}");
    Console.WriteLine($"List contains {names.Count} elements: [{string.Join(", ", names)}]");

    // Use with() to pass a comparer to the HashSet<T> constructor
    HashSet<string> caseInsensitiveSet = [with(StringComparer.OrdinalIgnoreCase), "Hello", "HELLO"];
    // caseInsensitiveSet contains only one element because "Hello" and "HELLO" are equal

    Console.WriteLine($"HashSet with case-insensitive comparer contains {caseInsensitiveSet.Count} elements: [{string.Join(", ", caseInsensitiveSet)}]");
    Console.WriteLine("Note: 'Hello' and 'HELLO' are treated as the same element due to OrdinalIgnoreCase comparer");
}

A gyűjteménykifejezés argumentumairól, beleértve a támogatott céltípusokat és korlátozásokat, további információt a Gyűjteménykifejezés argumentumai című témakörben talál.

Objektum-inicializálók gyűjteményi olvasható tulajdonságok inicializálásával

Egyes osztályok gyűjteménytulajdonságokkal rendelkeznek, amelyekben a tulajdonság írásvédett, például az CatsCatOwner alábbi esetben:

public class CatOwner
{
    public IList<Cat> Cats { get; } = new List<Cat>();
}

Nem használhatja a korábban tárgyalt gyűjtemény inicializáló szintaxisát, mivel a tulajdonság nem rendelhető hozzá új listához:

CatOwner owner = new CatOwner
{
    Cats = new List<Cat>
    {
        new Cat{ Name = "Sylvester", Age=8 },
        new Cat{ Name = "Whiskers", Age=2 },
        new Cat{ Name = "Sasha", Age=14 }
    }
};

Új bejegyzéseket Cats azonban az inicializálás szintaxisával és a lista létrehozásának kihagyásával (new List<Cat>az alábbi példában látható módon) adhat hozzá:

CatOwner owner = new CatOwner
{
    Cats =
    {
        new Cat{ Name = "Sylvester", Age=8 },
        new Cat{ Name = "Whiskers", Age=2 },
        new Cat{ Name = "Sasha", Age=14 }
    }
};

A hozzáadni kívánt bejegyzések kapcsos zárójelek között jelennek meg. Az előző kód megegyezik az írással:

CatOwner owner = new ();
owner.Cats.Add(new Cat{ Name = "Sylvester", Age=8 });
owner.Cats.Add(new Cat{ Name = "Whiskers", Age=2 });
owner.Cats.Add(new Cat{ Name = "Sasha", Age=14 });

Példák

Az alábbi példa egyesíti az objektum- és gyűjtemény-inicializálók fogalmait.

public class InitializationSample
{
    public class Cat
    {
        // Automatically implemented properties.
        public int Age { get; set; }
        public string? Name { get; set; }

        public Cat() { }

        public Cat(string name)
        {
            Name = name;
        }
    }

    public static void Main()
    {
        Cat cat = new Cat { Age = 10, Name = "Fluffy" };
        Cat sameCat = new Cat("Fluffy"){ Age = 10 };

        List<Cat> cats =
        [
            new Cat { Name = "Sylvester", Age = 8 },
            new Cat { Name = "Whiskers", Age = 2 },
            new Cat { Name = "Sasha", Age = 14 }
        ];

        List<Cat?> moreCats = new List<Cat?>
        {
            new Cat { Name = "Furrytail", Age = 5 },
            new Cat { Name = "Peaches", Age = 4 },
            null
        };

        List<Cat> allCats = [.. cats, new Cat { Name = "Łapka", Age = 5 }, cat, .. moreCats];

        // Display results.
        foreach (Cat? c in allCats)
        {
            if (c != null)
            {
                System.Console.WriteLine(c.Name);
            }
            else
            {
                System.Console.WriteLine("List element has null value.");
            }
        }
    }
    // Output:
    // Sylvester
    // Whiskers
    // Sasha
    // Łapka
    // Fluffy
    // Furrytail
    // Peaches
    // List element has null value.
}

Az alábbi példa bemutat egy objektumot, amely IEnumerable-t implementál és tartalmaz egy Add metódust több paraméterrel. Egy gyűjtemény inicializálóját használja, amely elemenként több elemet tartalmaz a listában, amelyek megfelelnek a Add metódus aláírásának.

public class FullExample
{
    class FormattedAddresses : IEnumerable<string>
    {
        private List<string> internalList = new();
        public IEnumerator<string> GetEnumerator() => internalList.GetEnumerator();

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => internalList.GetEnumerator();

        public void Add(string firstname, string lastname,
            string street, string city,
            string state, string zipcode) => internalList.Add($"""
            {firstname} {lastname}
            {street}
            {city}, {state} {zipcode}
            """
            );
    }

    public static void Main()
    {
        FormattedAddresses addresses = new FormattedAddresses()
        {
            {"John", "Doe", "123 Street", "Topeka", "KS", "00000" },
            {"Jane", "Smith", "456 Street", "Topeka", "KS", "00000" }
        };

        Console.WriteLine("Address Entries:");

        foreach (string addressEntry in addresses)
        {
            Console.WriteLine("\r\n" + addressEntry);
        }
    }

    /*
        * Prints:

        Address Entries:

        John Doe
        123 Street
        Topeka, KS 00000

        Jane Smith
        456 Street
        Topeka, KS 00000
        */
}

Add metódusok a params kulcsszóval változó számú argumentumot használhatnak, ahogy az az alábbi példában is látható. Ez a példa azt is bemutatja, hogy egy indexelő egyéni implementációja alapján inicializálhat egy gyűjteményt indexekkel. A C# 13-tól kezdve a params paraméter nem korlátozódik tömbre. Ez lehet gyűjteménytípus vagy felület.

public class DictionaryExample
{
    class RudimentaryMultiValuedDictionary<TKey, TValue> : IEnumerable<KeyValuePair<TKey, List<TValue>>> where TKey : notnull
    {
        private Dictionary<TKey, List<TValue>> internalDictionary = new Dictionary<TKey, List<TValue>>();

        public IEnumerator<KeyValuePair<TKey, List<TValue>>> GetEnumerator() => internalDictionary.GetEnumerator();

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => internalDictionary.GetEnumerator();

        public List<TValue> this[TKey key]
        {
            get => internalDictionary[key];
            set => Add(key, value);
        }

        public void Add(TKey key, params TValue[] values) => Add(key, (IEnumerable<TValue>)values);

        public void Add(TKey key, IEnumerable<TValue> values)
        {
            if (!internalDictionary.TryGetValue(key, out List<TValue>? storedValues))
            {
                internalDictionary.Add(key, storedValues = new());
            }
            storedValues.AddRange(values);
        }
    }

    public static void Main()
    {
        RudimentaryMultiValuedDictionary<string, string> rudimentaryMultiValuedDictionary1
            = new RudimentaryMultiValuedDictionary<string, string>()
            {
                {"Group1", "Bob", "John", "Mary" },
                {"Group2", "Eric", "Emily", "Debbie", "Jesse" }
            };
        RudimentaryMultiValuedDictionary<string, string> rudimentaryMultiValuedDictionary2
            = new RudimentaryMultiValuedDictionary<string, string>()
            {
                ["Group1"] = new List<string>() { "Bob", "John", "Mary" },
                ["Group2"] = new List<string>() { "Eric", "Emily", "Debbie", "Jesse" }
            };
        RudimentaryMultiValuedDictionary<string, string> rudimentaryMultiValuedDictionary3
            = new RudimentaryMultiValuedDictionary<string, string>()
            {
                {"Group1", new string []{ "Bob", "John", "Mary" } },
                { "Group2", new string[]{ "Eric", "Emily", "Debbie", "Jesse" } }
            };

        Console.WriteLine("Using first multi-valued dictionary created with a collection initializer:");

        foreach (KeyValuePair<string, List<string>> group in rudimentaryMultiValuedDictionary1)
        {
            Console.WriteLine($"\r\nMembers of group {group.Key}: ");

            foreach (string member in group.Value)
            {
                Console.WriteLine(member);
            }
        }

        Console.WriteLine("\r\nUsing second multi-valued dictionary created with a collection initializer using indexing:");

        foreach (KeyValuePair<string, List<string>> group in rudimentaryMultiValuedDictionary2)
        {
            Console.WriteLine($"\r\nMembers of group {group.Key}: ");

            foreach (string member in group.Value)
            {
                Console.WriteLine(member);
            }
        }
        Console.WriteLine("\r\nUsing third multi-valued dictionary created with a collection initializer using indexing:");

        foreach (KeyValuePair<string, List<string>> group in rudimentaryMultiValuedDictionary3)
        {
            Console.WriteLine($"\r\nMembers of group {group.Key}: ");

            foreach (string member in group.Value)
            {
                Console.WriteLine(member);
            }
        }
    }

    /*
        * Prints:

        Using first multi-valued dictionary created with a collection initializer:

        Members of group Group1:
        Bob
        John
        Mary

        Members of group Group2:
        Eric
        Emily
        Debbie
        Jesse

        Using second multi-valued dictionary created with a collection initializer using indexing:

        Members of group Group1:
        Bob
        John
        Mary

        Members of group Group2:
        Eric
        Emily
        Debbie
        Jesse

        Using third multi-valued dictionary created with a collection initializer using indexing:

        Members of group Group1:
        Bob
        John
        Mary

        Members of group Group2:
        Eric
        Emily
        Debbie
        Jesse
        */
}