Comment convertir IEnumerable en ObservableCollection?

130

Comment convertir IEnumerableen ObservableCollection?

c#

— KentZhou
source

209

Selon le MSDN

var myObservableCollection = new ObservableCollection<YourType>(myIEnumerable);

Cela créera une copie superficielle du IEnumerable actuel et le transformera en ObservableCollection.

— Scott Chamberlain
source

Est-ce plus rapide que d'utiliser une boucle ForEach pour insérer les éléments un par un dans la collection?

— Rexxo

4

@Rexxo il sera légèrement plus rapide de le faire avec le constructeur. En interne, il utilise unforeach pour copier les éléments dans la collection interne, mais si vous faites le foreach et l'appelez, Add il passera parInsertItem ce qui fera beaucoup de choses supplémentaires qui sont inutiles lors du remplissage initial, ce qui le ralentira légèrement.

— Scott Chamberlain

Simples et la meilleure réponse

— peterincumbria

74

Si vous travaillez avec des produits non génériques, IEnumerablevous pouvez le faire de cette façon:

public ObservableCollection<object> Convert(IEnumerable original)
{
    return new ObservableCollection<object>(original.Cast<object>());
}

Si vous travaillez avec générique, IEnumerable<T>vous pouvez le faire de cette façon:

public ObservableCollection<T> Convert<T>(IEnumerable<T> original)
{
    return new ObservableCollection<T>(original);
}

Si vous travaillez avec des éléments non génériques IEnumerablemais que vous connaissez le type d'éléments, vous pouvez le faire de cette façon:
```
public ObservableCollection<T> Convert<T>(IEnumerable original)
{
    return new ObservableCollection<T>(original.Cast<T>());
}
```

— Élisée
source

29

Pour rendre les choses encore plus simples, vous pouvez en créer une méthode d' extension .

public static class Extensions
{
    public static ObservableCollection<T> ToObservableCollection<T>(this IEnumerable<T> col)
    {
        return new ObservableCollection<T>(col);
    }
}

Ensuite, vous pouvez appeler la méthode sur chaque IEnumerable

var lst = new List<object>().ToObservableCollection();

— Markwilde
source

3

ObservableCollection<decimal> distinctPkgIdList = new ObservableCollection<decimal>();
guPackgIds.Distinct().ToList().ForEach(i => distinctPkgIdList.Add(i));

// distinctPkgIdList - ObservableCollection
// guPackgIds.Distinct() - IEnumerable

— Sudharshan
source

1

La fonction C # pour convertir le IEnumerable en ObservableCollection

private ObservableCollection<dynamic> IEnumeratorToObservableCollection(IEnumerable source)
    {

        ObservableCollection<dynamic> SourceCollection = new ObservableCollection<dynamic>();

        IEnumerator enumItem = source.GetEnumerator();
        var gType = source.GetType();
        string collectionFullName = gType.FullName;
        Type[] genericTypes = gType.GetGenericArguments();
        string className = genericTypes[0].Name;
        string classFullName = genericTypes[0].FullName;
        string assName = (classFullName.Split('.'))[0];

        // Get the type contained in the name string
        Type type = Type.GetType(classFullName, true);

        // create an instance of that type
        object instance = Activator.CreateInstance(type);
        List<PropertyInfo> oProperty = instance.GetType().GetProperties().ToList();
        while (enumItem.MoveNext())
        {

            Object instanceInner = Activator.CreateInstance(type);
            var x = enumItem.Current;

            foreach (var item in oProperty)
            {
                if (x.GetType().GetProperty(item.Name) != null)
                {
                    var propertyValue = x.GetType().GetProperty(item.Name).GetValue(x, null);
                    if (propertyValue != null)
                    {
                        PropertyInfo prop = type.GetProperty(item.Name);
                        prop.SetValue(instanceInner, propertyValue, null);
                    }
                }
            }

            SourceCollection.Add(instanceInner);
        }

        return SourceCollection;
    }

— B.Balamanigandan
source