C# 将KeyValuePair强制转换为KeyValuePair

最简单的施展方式是什么：

IList<KeyValuePair<Guid, object>>

到

无循环等。

如果您有KeyValuePair k，则可以执行以下操作：

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

不能在KeyValuePair和KeyValuePair之间强制转换，它们是不兼容的类型，它们的IList也是如此，除非您使用的类同时实现了这两种类型。通过使用ToString将Guid转换为字符串，可以创建具有类似值的新Guid：

要对IList执行此操作，必须执行某种循环。为了可读性，我建议使用LINQ：

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

当你说：

没有回路等

这是否意味着您有多个KeyValuePairs？所以说你有IEnumerable并且想要IEnumerable。。。您必须执行某种形式的循环来转换每个值：

因此，您可以非常轻松地使用LINQ语句：

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

这至少相当干净…

您可以创建一个无循环的包装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);
  }
}

---

var pair=new KeyValuePairguidObj.Key.ToString，guidObj.Value；你不能施放，你必须转换。对不起大家，忘记犯了一个错误-忘记了IList位！如果它真的是IList或List，那么您可以使用List.ConvertAll，它也会隐式循环。根据您的编辑，它是：

  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);
  }
}