Bagaimana cara mendapatkan Kamus kunci dengan nilai di C#?
Dictionary<string, string> types = new Dictionary<string, string>()
{
{"1", "one"},
{"2", "two"},
{"3", "three"}
};
Saya ingin sesuatu seperti ini:
getByValueKey(string value);
getByValueKey("")
harus kembali "1"
.
Apa cara terbaik melakukan hal ini? Mungkin HashTable, SortedLists?
Nilai-nilai tidak selalu harus unik sehingga anda harus melakukan pencarian. Anda dapat melakukan sesuatu seperti ini:
var myKey = types.FirstOrDefault(x => x.Value == "one").Key;
Jika nilai-nilai yang unik dan dimasukkan kurang sering daripada membaca, kemudian membuat invers kamus mana nilai-nilai kunci dan kunci-nilai.
Anda bisa melakukannya:
KeyValuePair<TKey, TValue>
's dalam kamus (yang akan menjadi cukup besar kinerja hit jika anda memiliki jumlah entri dalam kamus) Menggunakan Metode 1 jika kinerja tidak menjadi pertimbangan, menggunakan Metode 2 jika memori tidak menjadi pertimbangan.
Juga, semua kunci harus unik, tapi nilai-nilai yang tidak dibutuhkan untuk menjadi unik. Anda mungkin memiliki lebih dari satu kunci dengan nilai yang ditentukan.
Apakah ada alasan yang dapat anda't terbalik kunci-nilai hubungan?
Saya berada di situasi di mana Linq mengikat itu tidak tersedia dan harus memperluas lambda secara eksplisit. Hal ini mengakibatkan fungsi sederhana:
C# public static T KeyByValue<T, W>(Kamus ini<T, W> dict, W val) { Kunci T = default; foreach (KeyValuePair<T, W> pasangan di dict) { jika (EqualityComparer<P>.Default.Sama dengan(pasangan.Nilai, val)) { kunci = pasangan.Kunci; break; } } tombol kembali; }
Sebut saja seperti berikut:
public static void Main()
{
Dictionary<string, string> dict = new Dictionary<string, string>()
{
{"1", "one"},
{"2", "two"},
{"3", "three"}
};
string key = KeyByValue(dict, "two");
Console.WriteLine("Key: " + key);
}
Bekerja pada .NET 2.0 dan di lingkungan terbatas lainnya.
Saya telah menciptakan sebuah double-lookup kelas:
/// <summary>
/// dictionary with double key lookup
/// </summary>
/// <typeparam name="T1">primary key</typeparam>
/// <typeparam name="T2">secondary key</typeparam>
/// <typeparam name="TValue">value type</typeparam>
public class cDoubleKeyDictionary<T1, T2, TValue> {
private struct Key2ValuePair {
internal T2 key2;
internal TValue value;
}
private Dictionary<T1, Key2ValuePair> d1 = new Dictionary<T1, Key2ValuePair>();
private Dictionary<T2, T1> d2 = new Dictionary<T2, T1>();
/// <summary>
/// add item
/// not exacly like add, mote like Dictionary[] = overwriting existing values
/// </summary>
/// <param name="key1"></param>
/// <param name="key2"></param>
public void Add(T1 key1, T2 key2, TValue value) {
lock (d1) {
d1[key1] = new Key2ValuePair {
key2 = key2,
value = value,
};
d2[key2] = key1;
}
}
/// <summary>
/// get key2 by key1
/// </summary>
/// <param name="key1"></param>
/// <param name="key2"></param>
/// <returns></returns>
public bool TryGetValue(T1 key1, out TValue value) {
if (d1.TryGetValue(key1, out Key2ValuePair kvp)) {
value = kvp.value;
return true;
} else {
value = default;
return false;
}
}
/// <summary>
/// get key1 by key2
/// </summary>
/// <param name="key2"></param>
/// <param name="key1"></param>
/// <remarks>
/// 2x O(1) operation
/// </remarks>
/// <returns></returns>
public bool TryGetValue2(T2 key2, out TValue value) {
if (d2.TryGetValue(key2, out T1 key1)) {
return TryGetValue(key1, out value);
} else {
value = default;
return false;
}
}
/// <summary>
/// get key1 by key2
/// </summary>
/// <param name="key2"></param>
/// <param name="key1"></param>
/// <remarks>
/// 2x O(1) operation
/// </remarks>
/// <returns></returns>
public bool TryGetKey1(T2 key2, out T1 key1) {
return d2.TryGetValue(key2, out key1);
}
/// <summary>
/// get key1 by key2
/// </summary>
/// <param name="key2"></param>
/// <param name="key1"></param>
/// <remarks>
/// 2x O(1) operation
/// </remarks>
/// <returns></returns>
public bool TryGetKey2(T1 key1, out T2 key2) {
if (d1.TryGetValue(key1, out Key2ValuePair kvp1)) {
key2 = kvp1.key2;
return true;
} else {
key2 = default;
return false;
}
}
/// <summary>
/// remove item by key 1
/// </summary>
/// <param name="key1"></param>
public void Remove(T1 key1) {
lock (d1) {
if (d1.TryGetValue(key1, out Key2ValuePair kvp)) {
d1.Remove(key1);
d2.Remove(kvp.key2);
}
}
}
/// <summary>
/// remove item by key 2
/// </summary>
/// <param name="key2"></param>
public void Remove2(T2 key2) {
lock (d1) {
if (d2.TryGetValue(key2, out T1 key1)) {
d1.Remove(key1);
d2.Remove(key2);
}
}
}
/// <summary>
/// clear all items
/// </summary>
public void Clear() {
lock (d1) {
d1.Clear();
d2.Clear();
}
}
/// <summary>
/// enumerator on key1, so we can replace Dictionary by cDoubleKeyDictionary
/// </summary>
/// <param name="key1"></param>
/// <returns></returns>
public TValue this[T1 key1] {
get => d1[key1].value;
}
/// <summary>
/// enumerator on key1, so we can replace Dictionary by cDoubleKeyDictionary
/// </summary>
/// <param name="key1"></param>
/// <returns></returns>
public TValue this[T1 key1, T2 key2] {
set {
lock (d1) {
d1[key1] = new Key2ValuePair {
key2 = key2,
value = value,
};
d2[key2] = key1;
}
}
}
mungkin sesuatu seperti ini:
foreach (var keyvaluepair in dict)
{
if(Object.ReferenceEquals(keyvaluepair.Value, searchedObject))
{
//dict.Remove(keyvaluepair.Key);
break;
}
}
types.Values.ToList().IndexOf("one");
Nilai-nilai.Kedaftar() mengkonversi kamus nilai-nilai ke dalam Daftar benda-benda. IndexOf("") pencarian Daftar baru anda mencari "" dan mengembalikan Indeks yang akan sesuai indeks dari pasangan Kunci/Nilai dalam kamus.
Metode ini tidak peduli tentang kamus tombol, itu hanya mengembalikan indeks dari nilai yang anda cari.
Perlu diingat mungkin ada lebih dari satu "" nilai dalam kamus anda. Dan itu adalah alasan tidak ada "mendapatkan kunci" metode.
Kode di bawah ini hanya bekerja jika berisi Nilai yang Unik Data
public string getKey(string Value)
{
if (dictionary.ContainsValue(Value))
{
var ListValueData=new List<string>();
var ListKeyData = new List<string>();
var Values = dictionary.Values;
var Keys = dictionary.Keys;
foreach (var item in Values)
{
ListValueData.Add(item);
}
var ValueIndex = ListValueData.IndexOf(Value);
foreach (var item in Keys)
{
ListKeyData.Add(item);
}
return ListKeyData[ValueIndex];
}
return string.Empty;
}
Saya punya cara yang sangat sederhana untuk melakukan ini. Itu bekerja dengan sempurna bagi saya.
Dictionary<string, string> types = new Dictionary<string, string>();
types.Add("1", "one");
types.Add("2", "two");
types.Add("3", "three");
Console.WriteLine("Please type a key to show its value: ");
string rLine = Console.ReadLine();
if(types.ContainsKey(rLine))
{
string value_For_Key = types[rLine];
Console.WriteLine("Value for " + rLine + " is" + value_For_Key);
}