转换KeyValuePair <Guid, object> 到KeyValuePair <string, object>

Question

What would be the easiest way to cast:

IList<KeyValuePair<Guid, object>>

to

IList<KeyValuePair<string, object>>

without loops etc.

Answer 1

You can't cast between KeyValuePair<Guid, object> and KeyValuePair<string, object> , they are incompatible types (the same goes for IList<> s of them, unless you're using a class that implements both). You could create a new KeyValuePair<string, object> with similar values by using ToString() to turn the Guid into a string :

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

To do this to an IList<KeyValuePair<Guid, object>> , you'll have to do a loop of some sort. I'd suggest using LINQ, for readability:

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

Answer 2

You can make a wrapper IList class that will do it without loops - but you have to provide conversion (derived-parent, parent-derived) yourself.

Usage:

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

Wrapper class:

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

Answer 3

如果您有KeyValuePair<Guid, object> k，则可以执行以下操作：

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

Answer 4

When you say:

without loops etc.

Does this imply you have multiple KeyValuePairs ? So say you have IEnumerable<KeyValuePair<Guid, Object>> and want IEnumerable<KeyValuePair<string, Object>> ... You will HAVE to do some form of looping to convert each value:

So you could very easily do it with a LINQ statement:

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

This is at least pretty clean...