C#에서 값별로 Dictionary 키를 얻으려면 어떻게 하나요?
Dictionary<string, string> types = new Dictionary<string, string>()
{
{"1", "one"},
{"2", "two"},
{"3", "three"}
};
다음과 같은 것을 원합니다:
getByValueKey(string value);
getByValueKey("one")
는 `"1"'을 반환해야 합니다.
이 작업을 수행하는 가장 좋은 방법은 무엇인가요? 해시 테이블, 정렬 목록은 어떨까요?
그렇게 할 수 있습니다:
KeyValuePair
, TKey, TValue
를 반복합니다(딕셔너리에 항목이 많은 경우 성능이 크게 저하될 수 있음).성능이 중요하지 않은 경우 방법 1을 사용하고, 메모리가 중요하지 않은 경우 방법 2를 사용합니다.
또한 모든 키는 고유해야 하지만 값은 반드시 고유할 필요는 없습니다. 지정된 값을 가진 키가 두 개 이상 있을 수 있습니다.
키-값 관계를 바꿀 수 없는 이유가 있나요?
난 롬폭 상황을 확장하십시오 람다 (λ) 는 linq 바인딩하면 사용할 수 없고 직접 했다. 이 사고로 인해 있는 단순한 기능:
"'c # 공용 정적 T, T, W> KeyByValue<, (이 Dictionary<, T, W>. 딕트, W val) { T 키 = 기본. 포리치 (KeyValuePair<, T, W>. 페어당 딕트 에서) { if (EqualityComparer< W> 이데포t. 퀄스 (파르지팔루, val);;) { 키 = 페어당. 키. 브레이크. } } 주요 반품하십시오. } "'
Call it like 다음과 같습니다.
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);
}
Net 2.0 및 기타 제한된 환경 작동합니다.
내가 만든 이중 조회 클래스:
/// <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;
}
}
}
아마 이 같은 일이.
foreach (var keyvaluepair in dict)
{
if(Object.ReferenceEquals(keyvaluepair.Value, searchedObject))
{
//dict.Remove(keyvaluepair.Key);
break;
}
}
types.Values.ToList().IndexOf("one");
해당 객체의 목록을 발 주스토리스트 () 는 사전 값을 붙여넣습니다. IndexOf (" one";) 검색을 통해 새로운 목록을 찾는 one" "; 및 되돌려줍니다 되는 주요 / 가치 있는 인덱스화할 일치시킵니다 색인입니다 페어당 사전이므로
이 방법은 사전 키 값을 색인입니다 되돌려줍니다 높여줍니까 아랑곳하지 않고, 단지 당신이 찾고 있다.
염두에 둘 이상의 " one", 있을 수 있습니다. 자신의 가치를 사전이므로 그 때문에, key" " 얻을 수 없다. 메서드입니다.
아래 코드를 포함할 경우 고유 값 데이터 때만
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;
}
아주 간단한 방법이 있습니다. 저에게는 완벽하게 작동했습니다.
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);
}