Convertir une Liste<T> pour ObservableCollection<T> dans WP7

Je ne sais pas si c'est juste trop tard ou quoi, mais je ne vois pas comment faire...

Ce que je m'attends à faire, et que le navigateur d'objet est dit là, est-ce:

var oc = new ObservableCollection<T>( new List<T>() );

Mais ObservableCollection<T> a un seul constructeur sans paramètre. Le navigateur d'objet dit il y a 2 surcharges où Liste et IEnuerable devrait être en mesure d'être passée dans.

Est-il quelque chose de mal avec ma configuration? Les constructeurs sont pas sur la version de téléphone? (ce qui serait étrange)

Si ce vraiment n'existe pas, ce qui est la façon standard de le faire avec WP7 maintenant?

InformationsquelleAutor Josh Close | 2011-04-06

.net c#collections windows-phone-7

33

Les constructeurs ObservableCollection<T>(IEnumerable<T>) et ObservableCollection<T>(List<T>) ne sont pas pris en charge dans la note WP 7.0. Seul le constructeur sans paramètre est pris en charge dans la note WP 7.0. Les autres constructeurs sont disponibles dans Silverlight 4 et ci-dessus et WP 7.1 et au-dessus, tout simplement pas dans WP 7.0.

Je suppose que votre seule option est de prendre votre liste et ajouter les éléments dans une nouvelle instance d'un ObservableCollection individuellement, comme il n'existe pas de méthodes facilement accessibles pour les ajouter en vrac. Si ce n'est pas pour vous empêcher de mettre cela dans une extension ou une méthode statique de vous-même.
```
var list = new List<SomeType> { /* ... */ };
var oc = new ObservableCollection<SomeType>();
foreach (var item in list)
    oc.Add(item);
```
- Agréable de voir le téléphone icônes dans MSDN dans ce lien. Dommage que le navigateur d'objet ne peuvent pas comprendre, il n'est pas disponible.
- Je préfère arrêter de codage de le faire.
InformationsquelleAutor Jeff Mercado
88

ObservableCollection a plusieurs constructeurs qui ont paramètre d'entrée de la Liste des<T> ou IEnumerable<T>:

List<T> list = new List<T>();

ObservableCollection<T> collection = new ObservableCollection<T>(list);
- Pas dans Windows Phone 7, il ne le fait pas.
- Utilisé ce aujourd'hui (le 29 Avril, 2019), Cela devrait être la réponse valable d'autant que son utilisation de la ObservableCollection donné API du SDK. @eugène.sushilnikov peut gagner le Populiste badge 😉
InformationsquelleAutor eugene.sushilnikov
14

Pour convertir List<T> list de collection observable vous pouvez utiliser le code suivant:
```
var oc = new ObservableCollection<T>();
list.ForEach(x => oc.Add(x));
```
InformationsquelleAutor Ivan Salo

Vous devrez écrire votre propre méthode d'extension pour ce faire:

    public static class CollectionEx
    {
      ///<summary>
      ///Copies the contents of an IEnumerable list to an ObservableCollection
      ///</summary>
      ///<typeparam name="T">The type of objects in the source list</typeparam>
      ///<param name="enumerableList">The source list to be converted</param>
      ///<returns>An ObservableCollection containing the objects from the source list</returns>
      public static ObservableCollection<T> ToObservableCollection<T>( this IEnumerable<T> enumerableList )
      {
        if( enumerableList != null ) {
          //Create an emtpy observable collection object
          var observableCollection = new ObservableCollection<T>();

          //Loop through all the records and add to observable collection object
          foreach( var item in enumerableList ) {
            observableCollection.Add( item );
          }

          //Return the populated observable collection
          return observableCollection;
        }
        return null;
      }
    }

InformationsquelleAutor Praetorian

6

Méthode d'Extension de cette réponse IList<T> pour ObservableCollection<T> fonctionne assez bien
```
public static ObservableCollection<T> ToObservableCollection<T>(this IEnumerable<T> enumerable) {
  var col = new ObservableCollection<T>();
  foreach ( var cur in enumerable ) {
    col.Add(cur);
  }
  return col;
}
```
- Une autre utilité de la méthode d'extension est AddRange
- Encore une fois, je suis surprise de voir que c'est quelque chose qui n'existe pas déjà dans le cadre. Assez facile à mettre en œuvre, mais il faut probablement tous sur la place. J'ai toujours l'impression à la fin de la mise en œuvre de celle-ci aussi: IEnumerable<TSource>.Each( Action<TSource, int> predicate )
- À proximité: en ce qui concerne votre Each méthode, voir blogs.msdn.com/b/ericlippert/archive/2009/05/18/...
- Merci pour le lien! Lol: Clearly the sole purpose of a call to this method is to cause side effects. C'est tellement vrai. Je suis d'accord avec sa raison pourquoi elle ne devrait pas être là. C'est quelque chose que j'aime à utiliser, mais vous avez la possible fermeture de questions. Même avec Javascript si.
InformationsquelleAutor Luke Lowrey

ObservableCollection<FacebookUser_WallFeed> result = new ObservableCollection<FacebookUser_WallFeed>(FacebookHelper.facebookWallFeeds);

InformationsquelleAutor Zin Min

2

Si vous allez ajouter beaucoup d'articles, de considérer découlant de votre propre classe de ObservableCollection et en ajoutant des éléments aux Éléments protégés par membre - ce ne sera pas déclencher des événements en qualité d'observateurs. Lorsque vous avez terminé, vous pouvez augmenter les événements appropriés:
```
public class BulkUpdateObservableCollection<T> : ObservableCollection<T>
{
    public void AddRange(IEnumerable<T> collection)
    {
        foreach (var i in collection) Items.Add(i);
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
        OnPropertyChanged(new PropertyChangedEventArgs("Count"));
    }
 }
```
Lors de l'ajout de nombreux éléments à une ObservableCollection qui est déjà lié à un élément d'INTERFACE utilisateur (comme le LongListSelector), cela peut faire une énorme différence en termes de performances.

Avant d'ajouter les éléments, vous pouvez également vous assurer d'avoir suffisamment d'espace, de sorte que la liste n'est pas continuellement élargi par la mise en œuvre de cette méthode dans le BulkObservableCollection de la classe et de l'appeler avant de faire appel à AddRange:
```
    public void IncreaseCapacity(int increment)
    {
        var itemsList = (List<T>)Items;
        var total = itemsList.Count + increment;
        if (itemsList.Capacity < total)
        {
            itemsList.Capacity = total;
        }
    }
```
InformationsquelleAutor Damian

J'ai fait une extension alors maintenant, je peux juste charger une collection avec une liste en faisant:

MyObservableCollection.Load(MyList);

L'extension est:

public static class ObservableCollectionExtension
{
  public static ObservableCollection<T> Load<T>(this ObservableCollection<T> Collection, List<T> Source)
  {
          Collection.Clear();    
          Source.ForEach(x => Collection.Add(x));    
          return Collection;
   }
}

InformationsquelleAutor JBrooks

0

La réponse fournie par Zin Min résolu mon problème avec une seule ligne de code. Excellent!

J'ai eu le même problème de la conversion d'une Liste générique pour générique ObservableCollection pour utiliser les valeurs de ma Liste pour remplir un ComboBox qui participe à la liaison par l'intermédiaire d'une usine de classe pour une Fenêtre WPF.

_expediteStatuses = new ObservableCollection<ExpediteStatus>(_db.getExpediteStatuses());

Voici la signature de l'getExpediteStatuses méthode:

public List<ExpediteStatus> getExpediteStatuses()
- S'il vous plaît, regardez toutes les réponses. Il n'y a pas de réponse comme la mienne. Je me sens mal pour vous.
InformationsquelleAutor WolfDog

Utiliser ceci:

List<Class1> myList;
ObservableCollection<Class1> myOC = new ObservableCollection<Class1>(myList);

InformationsquelleAutor Ejrr1085

Vous devez vous connecter pour publier un commentaire.