投KeyValuePair <GUID，對象>到KeyValuePair <字符串，對象>

Question

什麼是最簡單的方法來投：

IList<KeyValuePair<Guid, object>> 

到

IList<KeyValuePair<string, object>> 

沒有循環等

Answer 1

您不能在KeyValuePair<Guid, object>和KeyValuePair<string, object>之間進行投射，它們是不兼容的類型（它們的IList<>也是如此，除非您使用的是實現兩者的類）。您可以通過使用ToString()打開Guid成string創建一個新的KeyValuePair<string, object>有類似值的：

var newKvp = new KeyValuePair<string, object>(old.Key.ToString(), old.Value); 

要做到這一點到IList<KeyValuePair<Guid, object>>，你就必須做某種形式的循環。我建議使用LINQ，爲便於閱讀：

IList<KeyValuePair<string, object>> newList = oldList 
    .Select(x => new KeyValuePair<string, object>(x.Key.ToString(), x.Value)) 
    .ToList(); 

Answer 2

如果你有一個KeyValuePair<Guid, object> k，你可以這樣做：

new KeyValuePair<string, object>(k.Key.ToString(), k.Value); 

Answer 3

當你說：

沒有循環等

這是否意味着你有多個KeyValuePairs？所以說你有​​，並希望IEnumerable<KeyValuePair<string, Object>> ......你將不得不做循環的每個值轉換的某種形式：

所以，你可以很容易地用LINQ語句做到這一點：

IEnumerable<KeyValuePair<Guid, Object>> x = ...; 
var newPairs = x.Select(kvp=> new KeyValuePair<string, object>(kvp.Key.ToString(), kvp.Value)); 

這是至少相當乾淨...

Answer 4

你可以做一個包裝IList類將做它沒有循環 - 但你必須提供自己的轉換（派生父，父派生）。

用法：

var originalList = new List<KeyValuePair<Guid, object>>(); 
    originalList.Add(new KeyValuePair<Guid, object>(Guid.Empty, "blabla")); 
    originalList.Add(new KeyValuePair<Guid, object>(Guid.NewGuid(), "foobar")); 

    var list = new ConvertibleList<KeyValuePair<string, object>, KeyValuePair<Guid, object>>(originalList, 
    (k) => new KeyValuePair<string, object>(k.Key.ToString("N"), k.Value), 
    (k) => new KeyValuePair<Guid, object>(new Guid(k.Key), k.Value)); 

包裝類：

public class ConvertibleList<Derived,Parent> : IList<Derived> { 
    private IList<Parent> m_List; 
    private Func<Parent, Derived> m_ParentToDerived; 
    private Func<Derived, Parent> m_DerivedToParent; 

    private class Enumerator : IEnumerator<Derived> { 
    private IEnumerator<Parent> m_Enumerator; 
    private Func<Parent, Derived> m_ParentToDerived; 

    public Enumerator(IEnumerator<Parent> enumerator, Func<Parent, Derived> parentToDerived) { 
     m_Enumerator = enumerator; 
     m_ParentToDerived = parentToDerived; 
    } 

    public Derived Current { 
     get { return m_ParentToDerived(m_Enumerator.Current); } 
    } 

    object IEnumerator.Current { 
     get { return m_ParentToDerived(m_Enumerator.Current); } 
    } 

    public bool MoveNext() { 
     return m_Enumerator.MoveNext(); 
    } 

    public void Reset() { 
     m_Enumerator.Reset(); 
    } 

    public void Dispose() { 
     m_Enumerator.Dispose(); 
    } 
    } 

    private class Enumerable : IEnumerable<Derived> { 
    private IEnumerable<Parent> m_Parent; 
    private Func<Parent, Derived> m_ParentToDerived; 

    public Enumerable(IEnumerable<Parent> parent, Func<Parent, Derived> parentToDerived) { 
     m_Parent = parent; 
     m_ParentToDerived = parentToDerived; 
    } 

    public IEnumerator<Derived> GetEnumerator() { 
     return new Enumerator(m_Parent.GetEnumerator(), m_ParentToDerived); 
    } 

    IEnumerator IEnumerable.GetEnumerator() { 
     return new Enumerator(m_Parent.GetEnumerator(), m_ParentToDerived); 
    } 
    } 

    public ConvertibleList(IList<Parent> list, Func<Parent, Derived> parentToDerived, Func<Derived, Parent> derivedToParent) { 
    if (list == null) { 
     throw new ArgumentNullException("list"); 
    } 
    m_List = list; 
    m_ParentToDerived = parentToDerived; 
    m_DerivedToParent = derivedToParent; 
    } 

    public int IndexOf(Derived item) { 
    return m_List.IndexOf(m_DerivedToParent(item)); 
    } 

    public void Insert(int index, Derived item) { 
    m_List.Insert(index, m_DerivedToParent(item)); 
    } 

    public void RemoveAt(int index) { 
    m_List.RemoveAt(index); 
    } 

    public Derived this[int index] { 
    get { return m_ParentToDerived(m_List[index]); } 
    set { m_List[index] = m_DerivedToParent(value); } 
    } 

    public void Add(Derived item) { 
    m_List.Add(m_DerivedToParent(item)); 
    } 

    public void Clear() { 
    m_List.Clear(); 
    } 

    public bool Contains(Derived item) { 
    return m_List.Contains(m_DerivedToParent(item)); 
    } 

    public void CopyTo(Derived[] array, int arrayIndex) { 
    var parentArray = new Parent[array.Length]; 
    for (var i = 0; i < array.Length; i++) { 
     parentArray[i] = m_DerivedToParent(array[i]); 
    } 
    m_List.CopyTo(parentArray, arrayIndex); 
    } 

    public int Count { 
    get { return m_List.Count; } 
    } 

    public bool IsReadOnly { 
    get { return m_List.IsReadOnly; } 
    } 

    public bool Remove(Derived item) { 
    return m_List.Remove(m_DerivedToParent(item)); 
    } 

    public IEnumerator<Derived> GetEnumerator() { 
    return new Enumerator(m_List.GetEnumerator(), m_ParentToDerived); 
    } 

    IEnumerator IEnumerable.GetEnumerator() { 
    return new Enumerator(m_List.GetEnumerator(), m_ParentToDerived); 
    } 
}