C# Language
Initialisering av samlingar

Anmärkningar

Insamlingsinitierare

Initiera en samlingstyp med värden:

var stringList = new List<string>
{
    "foo",
    "bar",
};

Insamlingsinitierare är syntaktiskt socker för Add() -samtal. Ovanstående kod motsvarar:

var temp = new List<string>();
temp.Add("foo");
temp.Add("bar");
var stringList = temp;

Observera att intialiseringen sker atomiskt med en tillfällig variabel för att undvika rasförhållanden.

För typer som erbjuder flera parametrar i deras Add() -metod, bifoga kommaseparerade argument i lockiga hängslen:

var numberDictionary = new Dictionary<int, string>
{
    { 1, "One" },
    { 2, "Two" },
};

Detta motsvarar:

var temp = new Dictionary<int, string>();
temp.Add(1, "One");
temp.Add(2, "Two");
var numberDictionarynumberDictionary = temp;

C # 6 Indexinitierare

Från och med C # 6 kan samlingar med indexerare initialiseras genom att specificera indexet som ska tilldelas i fyrkantiga parentes, följt av ett lika tecken följt av värdet som ska tilldelas.

Initialisering av ordbok

Ett exempel på denna syntax med en ordlista:

var dict = new Dictionary<string, int>
{
    ["key1"] = 1,
    ["key2"] = 50
};

Detta motsvarar:

var dict = new Dictionary<string, int>();
dict["key1"] = 1;
dict["key2"] = 50

Samlingsinitieringssyntaxen för att göra detta innan C # 6 var:

var dict = new Dictionary<string, int>
{
    { "key1", 1 },
    { "key2", 50 }
};

Vilket skulle motsvara:

var dict = new Dictionary<string, int>();
dict.Add("key1", 1);
dict.Add("key2", 50);

Så det finns en betydande skillnad i funktionalitet, eftersom den nya syntaxen använder indexeraren för det initialiserade objektet för att tilldela värden istället för att använda dess Add() -metod. Det betyder att den nya syntaxen bara kräver en allmänt tillgänglig indexerare och fungerar för alla objekt som har ett.

public class IndexableClass
{
    public int this[int index]
    {
        set 
        { 
            Console.WriteLine("{0} was assigned to index {1}", value, index);
        }
    }
}

var foo = new IndexableClass
{
    [0] = 10,
    [1] = 20
}

Detta skulle matas ut:

10 was assigned to index 0
20 was assigned to index 1

Samlingsinitierare i anpassade klasser

För att skapa en initialisering av IEnumerable måste den implementera IEnumerable gränssnitt och ha minst en Add metod. Sedan C # 6 kan alla samlingar som implementerar IEnumerable utökas med anpassade Add metoder med hjälp av förlängningsmetoder.

class Program
{
    static void Main()
    {
        var col = new MyCollection {
            "foo",
            { "bar", 3 },
            "baz",
            123.45d,
        };
    }
}

class MyCollection : IEnumerable
{
    private IList list = new ArrayList();

    public void Add(string item)
    {
        list.Add(item)
    }

    public void Add(string item, int count)
    {
        for(int i=0;i< count;i++) {
            list.Add(item);
        }
    }

    public IEnumerator GetEnumerator()
    {
        return list.GetEnumerator();
    }
}

static class MyCollectionExtensions
{
    public static void Add(this MyCollection @this, double value) => 
        @this.Add(value.ToString());
}

Samlingsinitierare med parametrarrayer

Du kan blanda normala parametrar och parametrar:

public class LotteryTicket : IEnumerable{
    public int[] LuckyNumbers;
    public string UserName;

    public void Add(string userName, params int[] luckyNumbers){
        UserName = userName;
        Lottery = luckyNumbers;
    }
}

Denna syntax är nu möjlig:

var Tickets = new List<LotteryTicket>{
    {"Mr Cool"  , 35663, 35732, 12312, 75685},
    {"Bruce"    , 26874, 66677, 24546, 36483, 46768, 24632, 24527},
    {"John Cena", 25446, 83356, 65536, 23783, 24567, 89337}
}

Använda samlingsinitierare inuti objektinitierare

public class Tag
{
    public IList<string> Synonyms { get; set; }
}

Synonyms är en egenskap av samlingstyp. När Tag skapas med syntax för Synonyms kan Synonyms också initialiseras med samlingsinitieringssyntax:

Tag t = new Tag 
{
    Synonyms = new List<string> {"c#", "c-sharp"}
};

Samlingsegenskapen kan vara readonly och kan fortfarande stödja syntax för samlingsinitierare. Tänk på detta modifierade exempel (egenskapen Synonyms nu en privat setter):

public class Tag
{
    public Tag()
    {
        Synonyms = new List<string>();
    }
    
    public IList<string> Synonyms { get; private set; }
}

Ett nytt Tag objekt kan skapas så här:

Tag t = new Tag 
{
    Synonyms = {"c#", "c-sharp"}
};

Detta fungerar eftersom samlingsinitierare bara är syntatiskt socker över samtal till Add() . Det skapas ingen ny lista här, kompilatorn genererar bara samtal till Add() på det existerande objektet.