Bir s├Âzl├╝kte yineleme yapman─▒n en iyi yolu nedir?


Al─▒nan cevaba git


C # 'da bir s├Âzl├╝─č├╝ yinelemenin birka├ž farkl─▒ yolunu g├Ârd├╝m. Standart bir yol var m─▒?


2402









Cevap say─▒s─▒n─▒ say: 27






 foreach(KeyValuePair<string, string> entry in myDictionary)
{
    // do something with entry.Value or entry.Key
}
 

3438







C # dilinde genel bir S├Âzl├╝k kullanmaya ├žal─▒┼č─▒yorsan─▒z, ba┼čka bir dilde bir ili┼čkisel dizi kullan─▒rs─▒n─▒z:

 foreach(var item in myDictionary)
{
  foo(item.Key);
  bar(item.Value);
}
 

Veya, yaln─▒zca anahtar koleksiyonunu yinelemeniz gerekirse,

 foreach(var item in myDictionary.Keys)
{
  foo(item);
}
 

Ve son olarak, yaln─▒zca de─čerlerle ilgileniyorsan─▒z:

 foreach(var item in myDictionary.Values)
{
  foo(item);
}
 

( var Anahtar kelimenin iste─če ba─čl─▒ bir C # 3.0 ve ├╝st├╝ bir ├Âzellik oldu─čuna dikkat edin, anahtarlar─▒n─▒z─▒ / de─čerlerinizi tam olarak burada da kullanabilirsiniz)


803







Baz─▒ durumlarda, ├ževrimsel uygulama taraf─▒ndan sa─članabilecek bir sayaca ihtiya├ž duyabilirsiniz. Bunun i├žin LINQ ElementAt a┼ča─č─▒dakileri sa─člar:

 for (int index = 0; index < dictionary.Count; index++) {
  var item = dictionary.ElementAt(index);
  var itemKey = item.Key;
  var itemValue = item.Value;
}
 

138







Anahtarlar─▒n veya de─čerlerin pe┼činde oldu─čunuza ba─čl─▒ olarak ...

MSDN Dictionary(TKey, TValue) S─▒n─▒f─▒ a├ž─▒klamas─▒ndan:

 // When you use foreach to enumerate dictionary elements,
// the elements are retrieved as KeyValuePair objects.
Console.WriteLine();
foreach( KeyValuePair<string, string> kvp in openWith )
{
    Console.WriteLine("Key = {0}, Value = {1}", 
        kvp.Key, kvp.Value);
}

// To get the values alone, use the Values property.
Dictionary<string, string>.ValueCollection valueColl =
    openWith.Values;

// The elements of the ValueCollection are strongly typed
// with the type that was specified for dictionary values.
Console.WriteLine();
foreach( string s in valueColl )
{
    Console.WriteLine("Value = {0}", s);
}

// To get the keys alone, use the Keys property.
Dictionary<string, string>.KeyCollection keyColl =
    openWith.Keys;

// The elements of the KeyCollection are strongly typed
// with the type that was specified for dictionary keys.
Console.WriteLine();
foreach( string s in keyColl )
{
    Console.WriteLine("Key = {0}", s);
}
 

92







Genellikle, belirli bir ba─člam olmadan "en iyi yolu" soran soran gibidir en iyi renk nedir ?

Bir yandan, bir├žok renk var ve en iyi renk yok. Bu, ihtiyaca ve s─▒kl─▒kla da tada ba─čl─▒d─▒r.

├ľte yandan, C #'daki bir S├Âzl├╝k ├╝zerinde yineleme yapman─▒n bir├žok yolu vard─▒r ve en iyi yolu yoktur. Bu, ihtiyaca ve s─▒kl─▒kla da tada ba─čl─▒d─▒r.

En basit yol

 foreach (var kvp in items)
{
    // key is kvp.Key
    doStuff(kvp.Value)
}
 

Yaln─▒zca de─čere ihtiyac─▒n─▒z varsa (araman─▒za izin verir, de─čerinden item daha okunabilir kvp.Value ).

 foreach (var item in items.Values)
{
    doStuff(item)
}
 

Belirli bir s─▒ralama d├╝zenine ihtiyac─▒n─▒z varsa

Genel olarak, yeni ba┼člayanlar bir S├Âzl├╝─č├╝n say─▒m s─▒ras─▒na ┼ča┼č─▒r─▒rlar.

LINQ, d├╝zeni (ve di─čer bir├žok ┼čeyi) belirlemeye yarayan k─▒sa bir s├Âzdizimi sa─člar, ├Ârne─čin:

 foreach (var kvp in items.OrderBy(kvp => kvp.Key))
{
    // key is kvp.Key
    doStuff(kvp.Value)
}
 

Yine, sadece de─čere ihtiyac─▒n─▒z olabilir. LINQ ayr─▒ca a┼ča─č─▒dakilere y├Ânelik ├Âzl├╝ bir ├ž├Âz├╝m sunar:

  • do─črudan de─čere g├Âre yinelenir ( item daha fazla okunabilir ┼čekilde okunmas─▒na izin verir kvp.Value )
  • ancak tu┼člara g├Âre s─▒ralanm─▒┼č

─░┼čte burada:

 foreach (var item in items.OrderBy(kvp => kvp.Key).Select(kvp => kvp.Value))
{
    doStuff(item)
}
 

Bu ├Ârneklerden yapabilece─činiz bir├žok ger├žek d├╝nya kullan─▒m durumu vard─▒r. E─čer belirli bir sipari┼če ihtiyac─▒n─▒z yoksa, sadece "en basit ┼čekilde" kalman─▒z yeterli (yukar─▒ bak─▒n)!


78







Foreach'nin standart bir yol oldu─čunu s├Âyleyebilirim, ancak bu ne arad─▒─č─▒na ba─čl─▒.

 foreach(var kvp in my_dictionary) {
  ...
}
 

Arad─▒─č─▒n ┼čey bu mu?


48







Bunu ayr─▒ca ├žok i┼č par├žac─▒kl─▒ i┼čleme i├žin b├╝y├╝k s├Âzl├╝klerde de deneyebilirsiniz.

 dictionary
.AsParallel()
.ForAll(pair => 
{ 
    // Process pair.Key and pair.Value here
});
 

37


2015-06-11





Bu sorunun zaten ├žok fazla yan─▒t─▒ oldu─čunu takdir ediyorum ama biraz ara┼čt─▒rma yapmak istedim.

Bir s├Âzl├╝k ├╝zerinde yineleme, bir dizi gibi bir ┼čey ├╝zerinde yineleme ile kar┼č─▒la┼čt─▒r─▒ld─▒─č─▒nda olduk├ža yava┼č olabilir. Testlerimde, bir dizi ├╝zerinde yineleme 0.015003 saniye s├╝rd├╝, bir s├Âzl├╝kte yineleme (ayn─▒ say─▒da ├Â─čeye sahip) 0.0365073 saniye s├╝rd├╝, bu 2.4 kat daha uzun! Yine de ├žok daha b├╝y├╝k farkl─▒l─▒klar g├Ârd├╝m. Kar┼č─▒la┼čt─▒rma i├žin bir Liste 0.00215043 saniye aras─▒nda bir yerdeydi.

Ancak, bu elma ve portakallar─▒ kar┼č─▒la┼čt─▒rmak gibidir. Demek istedi─čim, s├Âzl├╝kler ├╝zerinde yineleme yapmak yava┼čt─▒r.

S├Âzl├╝kler aramalar i├žin optimize edilmi┼čtir, bu y├╝zden akl─▒mda iki y├Ântem olu┼čturdum. Biri basit├že foreach yapar, di─čeri tu┼člar─▒ tekrar eder ve sonra bakar.

 public static string Normal(Dictionary<string, string> dictionary)
{
    string value;
    int count = 0;
    foreach (var kvp in dictionary)
    {
        value = kvp.Value;
        count++;
    }

    return "Normal";
}
 

Bu, anahtarlar─▒ y├╝kler ve onlar─▒n yerine tekrar eder (anahtarlar─▒ bir dizgeye [] ├žekmeyi de denedim, ancak fark ├Ânemsizdi.

 public static string Keys(Dictionary<string, string> dictionary)
{
    string value;
    int count = 0;
    foreach (var key in dictionary.Keys)
    {
        value = dictionary[key];
        count++;
    }

    return "Keys";
}
 

Bu ├Ârnekte normal foreach testi 0.0310062, anahtar versiyonu 0.2205441 alm─▒┼čt─▒r. T├╝m anahtarlar─▒n y├╝klenmesi ve t├╝m aramalar─▒n yinelenmesi a├ž─▒k├ža LOT daha yava┼čt─▒r!

Son bir test i├žin, anahtarlar─▒ burada kullanman─▒n herhangi bir yarar─▒ olup olmad─▒─č─▒n─▒ g├Ârmek i├žin yinelememi on kez yapt─▒m (bu noktada sadece merak ettim):

─░┼čte neler olup bitti─čini g├Ârselle┼čtirmenize yard─▒mc─▒ olursa, RunTest y├Ântemi.

 private static string RunTest<T>(T dictionary, Func<T, string> function)
{            
    DateTime start = DateTime.Now;
    string name = null;
    for (int i = 0; i < 10; i++)
    {
        name = function(dictionary);
    }
    DateTime end = DateTime.Now;
    var duration = end.Subtract(start);
    return string.Format("{0} took {1} seconds", name, duration.TotalSeconds);
}
 

Burada normal foreach ├žal─▒┼čmas─▒ 0.2820564 saniye s├╝rd├╝ (bekledi─činiz gibi tek bir yinelemeden yakla┼č─▒k on kat daha uzun). Anahtarlar─▒n yinelenmesi 2.2249449 saniye s├╝rd├╝.

Eklemek i├žin D├╝zenlendi: Di─čer cevaplardan baz─▒lar─▒n─▒ okumak, S├Âzl├╝k yerine S├Âzl├╝k kullanm─▒┼č olsayd─▒m ne olaca─č─▒n─▒ sorgulam─▒┼čt─▒. Bu ├Ârnekte, dizi 0.0120024 saniye, liste 0.0185037 saniye ve s├Âzl├╝k 0.0465093 saniye s├╝rm├╝┼čt├╝r. Veri t├╝r├╝n├╝n s├Âzl├╝─č├╝n ne kadar yava┼č oldu─ču konusunda bir fark yaratmas─▒ beklenir.

Sonu├žlar─▒m neler ?

  • Yapabiliyorsan─▒z bir s├Âzl├╝kte yineleme yapmaktan ka├ž─▒n─▒n, ayn─▒ veriyi i├žeren bir dizi ├╝zerinde yinelemekten ├žok daha yava┼čt─▒rlar.
  • Bir s├Âzl├╝─č├╝ yinelemeyi se├žerseniz, ├žok ak─▒ll─▒ olmaya ├žal─▒┼čmay─▒n, daha yava┼č olmas─▒na ra─čmen standart foreach y├Ântemini kullanmaktan ├žok daha k├Ât├╝ ┼čeyler yapabilirsiniz.

28







├çok fazla se├ženek var. Ki┼čisel favorim KeyValuePair taraf─▒ndan

 Dictionary<string, object> myDictionary = new Dictionary<string, object>();
// Populate your dictionary here

foreach (KeyValuePair<string,object> kvp in myDictionary)
{
     // Do some interesting things
}
 

Anahtarlar ve De─čerler Koleksiyonlar─▒'n─▒ da kullanabilirsiniz


26


2008-09-26





C # 7.0 , Deconstructors'─▒ tan─▒tt─▒ ve .NET Core 2.0+ Uygulamas─▒n─▒kullan─▒yorsan─▒z, yap─▒ KeyValuePair<> zaten Deconstruct() sizin i├žin. Yani yapabilirsin:

 var dic = new Dictionary<int, string>() { { 1, "One" }, { 2, "Two" }, { 3, "Three" } };
foreach (var (key, value) in dic) {
    Console.WriteLine($"Item [{key}] = {value}");
}
//Or
foreach (var (_, value) in dic) {
    Console.WriteLine($"Item [NO_ID] = {value}");
}
//Or
foreach ((int key, string value) in dic) {
    Console.WriteLine($"Item [{key}] = {value}");
}
 


g├Âr├╝nt├╝ tan─▒m─▒n─▒ buraya girin


25







Biriyle ayr─▒┼čma .NET Framework 4.7 kullanabilirsiniz

 var fruits = new Dictionary<string, int>();
...
foreach (var (fruit, number) in fruits)
{
    Console.WriteLine(fruit + ": " + number);
}
 

Bu kodun daha d├╝┼č├╝k C # s├╝r├╝mlerinde ├žal─▒┼čmas─▒n─▒ sa─člamak i├žin bir System.ValueTuple NuGet package yere ekleyin ve yaz─▒n

 public static class MyExtensions
{
    public static void Deconstruct<T1, T2>(this KeyValuePair<T1, T2> tuple,
        out T1 key, out T2 value)
    {
        key = tuple.Key;
        value = tuple.Value;
    }
}
 

12







A┼ča─č─▒da yinelemeyi ├Ânerdin

 Dictionary<string,object> myDictionary = new Dictionary<string,object>();
//Populate your dictionary here

foreach (KeyValuePair<string,object> kvp in myDictionary) {
    //Do some interesting things;
}
 

FYI, foreach de─čerin nesne t├╝r├╝ olmas─▒ durumunda ├žal─▒┼čmaz.


11


2009-10-28





S├Âzl├╝─č├╝ tekrarlamak i├žin en basit form:

 foreach(var item in myDictionary)
{ 
    Console.WriteLine(item.Key);
    Console.WriteLine(item.Value);
}
 

9


2016-10-02





C # 7 kullanarak , bu uzant─▒ y├Ântemini ├ž├Âz├╝m├╝n├╝z├╝n herhangi bir projesine ekleyin:

 public static class IDictionaryExtensions
{
    public static IEnumerable<(TKey, TValue)> Tuples<TKey, TValue>(
        this IDictionary<TKey, TValue> dict)
    {
        foreach (KeyValuePair<TKey, TValue> kvp in dict)
            yield return (kvp.Key, kvp.Value);
    }
}
 


Ve bu basit s├Âzdizimini kullan─▒n

 foreach (var(id, value) in dict.Tuples())
{
    // your code using 'id' and 'value'
}
 


Ya da bunu tercih ederseniz

 foreach ((string id, object value) in dict.Tuples())
{
    // your code using 'id' and 'value'
}
 


Geleneksel yerine

 foreach (KeyValuePair<string, object> kvp in dict)
{
    string id = kvp.Key;
    object value = kvp.Value;

    // your code using 'id' and 'value'
}
 


Uzatma y├Ântemi d├Ân├╝┼čt├╝ren KeyValuePair , aramalar─▒n─▒zdan IDictionary<TKey, TValue> kesinlikle yaz─▒l─▒ i├žine tuple bu yeni konforlu s├Âzdizimini kullanmak i├žin izin.

Gerekli s├Âzl├╝k giri┼člerini -just- 'a ├ževirir tuples , bu y├╝zden t├╝m s├Âzl├╝─č├╝ ├ževirmez tuples , bununla ilgili performans kayg─▒s─▒ yoktur.

Do─črudan tuple kullanma ile kar┼č─▒la┼čt─▒rmaya y├Ânelik bir uzant─▒ olu┼čturma y├Ântemi ├ža─č─▒rman─▒n yaln─▒zca k├╝├ž├╝k bir maliyeti vard─▒r KeyValuePair ; bu KeyValuePair ├Âzellik, ├Âzelliklerini Key ve Value yine de yeni d├Âng├╝ de─či┼čkenlerine atarsan─▒z, sorun olmamal─▒d─▒r .

Uygulamada, bu yeni s├Âzdizimi, hala sadece belirli bir noktada kullanmama se├žene─čine sahip oldu─čunuz d├╝┼č├╝k seviyeli ultra y├╝ksek performans senaryolar─▒ hari├ž, ├žo─ču durumda ├žok uygundur.

┼×una bir g├Âz at─▒n: MSDN Blog - C # 7'deki yeni ├Âzellikler


8







Bazen yaln─▒zca numaraland─▒r─▒lacak de─čerlere ihtiyac─▒n─▒z varsa, s├Âzl├╝─č├╝n de─čer koleksiyonunu kullan─▒n:

 foreach(var value in dictionary.Values)
{
    // do something with entry.Value only
}
 

En h─▒zl─▒ y├Ântem oldu─čunu belirten bu yaz─▒n─▒n bildirdi─či: http://alexpinsker.blogspot.hk/2010/02/c-fastest-way-to-iterate-over.html


6







Bu y├Ântemi MSDN'deki DictionaryBase s─▒n─▒f─▒ belgelerinde buldum:

 foreach (DictionaryEntry de in myDictionary)
{
     //Do some stuff with de.Value or de.Key
} 

DictionaryBase'den miras kalan bir s─▒n─▒fta do─čru ├žal─▒┼čabildi─čim tek ki┼či buydu.


5


2009-02-17





C # 7'den itibaren nesneleri de─či┼čkenlere d├Ân├╝┼čt├╝rebilirsiniz. Bunun bir s├Âzl├╝kte yinelemenin en iyi yolu oldu─čuna inan─▒yorum.

├ľrnek:

KeyValuePair<TKey, TVal> Bunu yap─▒┼čt─▒ran bir uzant─▒ y├Ântemi olu┼čturun :

 public static void Deconstruct<TKey, TVal>(this KeyValuePair<TKey, TVal> pair, out TKey key, out TVal value)
{
   key = pair.Key;
   value = pair.Value;
}
 

Herhangi bir Dictionary<TKey, TVal> ┼čekilde a┼ča─č─▒dakileri yineleyin

 // Dictionary can be of any types, just using 'int' and 'string' as examples.
Dictionary<int, string> dict = new Dictionary<int, string>();

// Deconstructor gets called here.
foreach (var (key, value) in dict)
{
   Console.WriteLine($"{key} : {value}");
}
 

4







.NET 4.0+ uygulamas─▒ndan faydalanaca─č─▒m ve ba┼člang─▒├žta kabul edilene g├╝ncellenmi┼č bir cevap verece─čim:

 foreach(var entry in MyDic)
{
    // do something with entry.Value or entry.Key
}
 

3







MSDNÔÇÖnin resmi dok├╝mantasyonuna g├Âre S├Âzl├╝k ├╝zerinden yineleme yapman─▒n standart yolu ┼čudur:

 foreach (DictionaryEntry entry in myDictionary)
{
     //Read entry.Key and entry.Value here
}
 

3


2016-07-28





Bunun ├žok eski bir soru oldu─čunu biliyorum, ancak yararl─▒ olabilecek baz─▒ uzatma y├Ântemleri olu┼čturdum:

     public static void ForEach<T, U>(this Dictionary<T, U> d, Action<KeyValuePair<T, U>> a)
    {
        foreach (KeyValuePair<T, U> p in d) { a(p); }
    }

    public static void ForEach<T, U>(this Dictionary<T, U>.KeyCollection k, Action<T> a)
    {
        foreach (T t in k) { a(t); }
    }

    public static void ForEach<T, U>(this Dictionary<T, U>.ValueCollection v, Action<U> a)
    {
        foreach (U u in v) { a(u); }
    }
 

Bu ┼čekilde ┼č├Âyle kod yazabilirim:

 myDictionary.ForEach(pair => Console.Write($"key: {pair.Key}, value: {pair.Value}"));
myDictionary.Keys.ForEach(key => Console.Write(key););
myDictionary.Values.ForEach(value => Console.Write(value););
 

3


2019-06-14





S├Âylerseniz, varsay─▒lan olarak de─čerler koleksiyonu ├╝zerinde yineleme yapmak istiyorsan─▒z, IEnumerable <> ├Â─česini uygulayabilece─činize inan─▒yorum, burada T, s├Âzl├╝kteki de─čerler nesnesinin t├╝r├╝ ve "this" bir S├Âzl├╝k't├╝r.

 public new IEnumerator<T> GetEnumerator()
{
   return this.Values.GetEnumerator();
}
 

2


2008-12-09





 var dictionary = new Dictionary<string, int>
{
    { "Key", 12 }
};

var aggregateObjectCollection = dictionary.Select(
    entry => new AggregateObject(entry.Key, entry.Value));
 

1







Sadece 2 sentimi eklemek istedim, ├ž├╝nk├╝ ├žo─ču cevap foreach d├Âng├╝s├╝yle ilgili. L├╝tfen a┼ča─č─▒daki koda bir g├Âz at─▒n:

 Dictionary<String, Double> myProductPrices = new Dictionary<String, Double>();

//Add some entries to the dictionary

myProductPrices.ToList().ForEach(kvP => 
{
    kvP.Value *= 1.15;
    Console.Writeline(String.Format("Product '{0}' has a new price: {1} $", kvp.Key, kvP.Value));
});
 

Buna, ek bir '.ToList ()' ├ža─čr─▒s─▒ eklenirse , ├Âzellikle b├╝y├╝k s├Âzl├╝klerle ├žal─▒┼č─▒rken ve paralel olarak ├žal─▒┼čt─▒r─▒rken, ├Âzellikle de, foreach ve someList.Foreach () {} i├žin belirtildi─či gibi ) se├ženek / hi├ž bir etkisi olmaz.

Ayr─▒ca, bir foreach d├Âng├╝s├╝ i├žindeki 'Value' ├Âzelli─čine de─čer atayamayaca─č─▒n─▒z─▒ unutmay─▒n. ├ľte yandan, 'Anahtar'─▒ da de─či┼čtirebilecek ve muhtemelen ├žal─▒┼čma zaman─▒nda ba┼č─▒n─▒z─▒ belaya sokabileceksiniz.

Anahtarlar─▒ ve De─čerleri yaln─▒zca "okumak" istedi─činizde, IEnumerable.Select () ├Â─česini de kullanabilirsiniz.

 var newProductPrices = myProductPrices.Select(kvp => new { Name = kvp.Key, Price = kvp.Value * 1.15 } );
 

1


2016-09-16





S├Âzl├╝k ├╝zerinde dola┼čmak i├žin bir uzant─▒ yazd─▒m.

 public static class DictionaryExtension
{
    public static void ForEach<T1, T2>(this Dictionary<T1, T2> dictionary, Action<T1, T2> action) {
        foreach(KeyValuePair<T1, T2> keyValue in dictionary) {
            action(keyValue.Key, keyValue.Value);
        }
    }
}
 

Sonra arayabilirsin

 myDictionary.ForEach((x,y) => Console.WriteLine(x + " - " + y));
 

1







S├Âzl├╝k <TKey, TValue> c # 'da genel bir toplama s─▒n─▒f─▒d─▒r ve verileri anahtar de─čer bi├žiminde saklar. Anahtar benzersiz olmal─▒ ve bo┼č olamaz, de─čer ├žo─čalt─▒labilir ve null olabilir. bir anahtar─▒ ve de─čerini temsil eden KeyValuePair <TKey, TValue> yap─▒s─▒ olarak de─čerlendirilir. ve bu nedenle, eleman─▒n yinelenmesi s─▒ras─▒nda KeyValuePair <TKey, TValue> eleman tipini almal─▒y─▒z. ├ľrnek a┼ča─č─▒da.

 Dictionary<int, string> dict = new Dictionary<int, string>();
dict.Add(1,"One");
dict.Add(2,"Two");
dict.Add(3,"Three");

foreach (KeyValuePair<int, string> item in dict)
{
    Console.WriteLine("Key: {0}, Value: {1}", item.Key, item.Value);
}
 

0







kullan─▒m aras─▒nda bir tart─▒┼čma bulunan en y├╝ksek r├╝tbeli mesajlara ek olarak

 foreach(KeyValuePair<string, string> entry in myDictionary)
{
    // do something with entry.Value or entry.Key
}
 

veya

 foreach(var entry in myDictionary)
{
    // do something with entry.Value or entry.Key
}
 

En eksiksiz olan─▒ a┼ča─č─▒daki gibidir ├ž├╝nk├╝ s├Âzl├╝k t├╝r├╝n├╝ ba┼člang─▒├žtan itibaren g├Ârebilirsiniz, kvp KeyValuePair

 var myDictionary = new Dictionary<string, string>(x);//fill dictionary with x

foreach(var kvp in myDictionary)//iterate over dictionary
{
    // do something with kvp.Value or kvp.Key
}
 

-3







S├Âzl├╝kler ├Âzel listelerdir, listedeki her de─čer de de─či┼čken olan bir anahtara sahiptir. S├Âzl├╝─če g├╝zel bir ├Ârnek telefon rehberidir.

    Dictionary<string, long> phonebook = new Dictionary<string, long>();
    phonebook.Add("Alex", 4154346543);
    phonebook["Jessica"] = 4159484588;
 

Bir s├Âzl├╝k tan─▒mlarken, iki t├╝rden genel bir tan─▒m vermemiz gerekti─čine dikkat edin - anahtar─▒n t├╝r├╝ ve de─čerin t├╝r├╝. Bu durumda, anahtar bir dizedir, ancak de─čer bir tamsay─▒d─▒r.

Ayr─▒ca, parantez operat├Âr├╝n├╝ kullanarak veya Ekle y├Ântemini kullanarak s├Âzl├╝─če tek bir de─čer eklemenin iki yolu vard─▒r.

Bir s├Âzl├╝─č├╝n i├žinde belirli bir anahtar olup olmad─▒─č─▒n─▒ kontrol etmek i├žin ContainsKey y├Ântemini kullanabiliriz:

 Dictionary<string, long> phonebook = new Dictionary<string, long>();
phonebook.Add("Alex", 415434543);
phonebook["Jessica"] = 415984588;

if (phonebook.ContainsKey("Alex"))
{
    Console.WriteLine("Alex's number is " + phonebook["Alex"]);
}
 

Bir ├Â─čeyi s├Âzl├╝kten ├ž─▒karmak i├žin Kald─▒r y├Ântemini kullanabiliriz. Bir ├Â─čeyi s├Âzl├╝kten anahtar─▒yla kald─▒rmak h─▒zl─▒ ve ├žok etkilidir. Bir ├Â─čeyi de─čerini kullanarak Listeden kald─▒r─▒rken, i┼člem Kald─▒r i┼člevinin aksine, i┼člem yava┼č ve verimsiz.

 Dictionary<string, long> phonebook = new Dictionary<string, long>();
phonebook.Add("Alex", 415434543);
phonebook["Jessica"] = 415984588;

phonebook.Remove("Jessica");
Console.WriteLine(phonebook.Count);
 

-4