c# - net - system collection

Convertir lista<T> a ObservableCollection<T> en WP7

Question

No sé si es demasiado tarde o qué, pero no veo cómo hacer esto ...

Lo que espero hacer, y lo que el buscador de objetos dice que está allí, es este:

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

Pero ObservableCollection<T> tiene un único constructor sin parámetros. El buscador de objetos dice que hay 2 sobrecargas donde List y IEnuerable deberían poder pasar.

¿Hay algún problema con mi configuración? ¿Los constructores no están en la versión del teléfono? (eso sería extraño)

Si esto realmente no existe, ¿cuál es la forma estándar de hacer esto con WP7 ahora?

Answer 1

Deberá escribir su propio método de extensión para hacer esto:

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

Answer 2

El método de extensión de esta respuesta IList <T> a ObservableCollection <T> funciona bastante 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;
}

Answer 3

Hice una extensión así que ahora puedo cargar una colección con una lista haciendo:

MyObservableCollection.Load(MyList);

La extensión es:

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

Answer 4

La respuesta proporcionada por Zin Min resolvió mi problema con una sola línea de código. ¡Excelente!

Estaba teniendo el mismo problema de convertir una Lista genérica en una ObservableCollection genérica para usar los valores de mi Lista para rellenar un ComboBox que participa en el enlace a través de una clase de fábrica para una Ventana de WPF.

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

Aquí está la firma del método getExpediteStatuses:

lista pública <ExpediteStatus> getExpediteStatuses ()

Answer 5

Los constructores ObservableCollection<T>(IEnumerable<T>) y ObservableCollection<T>(List<T>) no son compatibles con WP 7.0. Solo el constructor sin parámetros es compatible con WP 7.0. Los otros constructores están disponibles en Silverlight 4 y superior y WP 7.1 y superior, solo que no en WP 7.0.

Supongo que su única opción es tomar su lista y agregar los elementos en una nueva instancia de un ObservableCollection individualmente, ya que no hay métodos disponibles para agregarlos a granel. Aunque eso no es para impedirte poner esto en una extensión o método estático tú mismo.

var list = new List<SomeType> { /* ... */ };
var oc = new ObservableCollection<SomeType>();
foreach (var item in list)
oc.Add(item);

Answer 6

ObservableCollection tiene varios constructores que tienen un parámetro de entrada de List <T> o IEnumerable <T>:
List<T> list = new List<T>();
ObservableCollection<T> collection = new ObservableCollection<T>(list);

Answer 7

Para convertir la List<T> list en una colección observable, puede usar el siguiente código:

var oc = new ObservableCollection<T>();
list.ForEach(x => oc.Add(x));

Answer 8

Si vas a agregar muchos elementos, considera derivar tu propia clase de ObservableCollection y agregar elementos al miembro de Items protegido; esto no generará eventos en los observadores. Cuando hayas terminado, puedes plantear los eventos apropiados:

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

Al agregar muchos elementos a un ObservableCollection que ya está vinculado a un elemento de UI (como LongListSelector), esto puede generar una gran diferencia de rendimiento.

Antes de agregar los elementos, también puede asegurarse de tener suficiente espacio para que la lista no se expanda continuamente implementando este método en la clase BulkObservableCollection y llamándolo antes de llamar a AddRange:

 public void IncreaseCapacity(int increment)
{
var itemsList = (List<T>)Items;
var total = itemsList.Count + increment;
if (itemsList.Capacity < total)
{
itemsList.Capacity = total;
}
}

Answer 9

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