Problemas con los metodos del List

"CSharp" wrote in message
news:

Se me esta presentando un problema al intentar manipular varias listas en
una misma funcion.
El problema es el siguiente:
Tengo
List<Objeto> lista1 = new List<Objeto>();
List<Objeto> lista2 = new List<Objeto>();
lista1.Add(Objeto1);
lista1.Add(Objeto2);
lista1.Add(Objeto3);
lista2 = lista1;
lista1.Clear();

En lo anterior, se llena la lista1 con tres objetos, y luego asigno esta
lista1 a la lista2, entonces ambas listas (lista1 y lista2) deben ser
iguales. Pero al ejecutar el metodo Clear() a la lista1, tambien afecta la
lista2, quedando finalmente ambas listas vacias.

Que esta ocurriendo? y como puedo solucionarlo??

Estás confundiendo el comportamiento de las variables de tipo Referencia
con el de las variables de tipo Valor. Cuando haces variable1=variable2 y
las dos variables son de tipo Valor (por ejemplo, son "int"), entonces
variable2 se copia en variable1, y las dos copias son independientes.
Pero cuando las variables son de tipo Referencia, no contienen
directamente los datos, sino que los datos se asignan en una zona de memoria
separada, denominada el Heap. Al hacer el "new", se asigna memoria en el
Heap, y dentro de la variable lo único que se guarda es una especie de
"puntero" (que se llama Referencia) que apunta a esa memoria reservada en el
Heap. Cuando haces variable1=variable2, lo que se copia es la referencia,
pero no se copia toda la memoria que hay en el Heap y que contiene los
datos. Asi pues, despues de hacer la copia, las dos variables señalan al
mismo area de memoria, y por lo tanto los datos que modificas a partir de
una se ven modificados en la otra.

Veamos lo que hacen tus sentencias:

List<Objeto> lista1 = new List<Objeto>();

Se asigna espacio en el Heap para contener un List<Objeto>, y la
referencia a dicho espacio (llamémosle espacio1) se guarda en lista1.

List<Objeto> lista2 = new List<Objeto>();

Se asigna espacio en el Heap para contener un List<Objeto>, y la
referencia a dicho espacio (llamémosle espacio2) se guarda en lista2.

lista1.Add(Objeto1);
lista1.Add(Objeto2);
lista1.Add(Objeto3);

Se han metido 3 objetos en el espacio1.

lista2 = lista1;

Se copia la referencia al espacio1 dentro de lista2. Ahora ya no existe
ninguna referencia al espacio2, por lo que éste es inalcanzable y queda
disponible para ser destruido por el Garbage Collector.

lista1.Clear();

Se vacía todo lo que había en la zona a la que apunta lista1, es decir,
el espacio1.

Si ahora pides el contenido de lista2, como apunta al espacio1 y lo acabamos
de vaciar, te dice que no contiene nada.

Es una buena pregunta, no se si existe un metodo que permita clonar un
List<T> en otro, pero creo lo mas acertado sera crearte un metodo que
recorra la lista1 e inserte cada elemento dentro de la lista2. Es la
solucion mas practica, aunque encuentro raro que no haya un metodo para este
tipo de cosas.



"CSharp" escribió en el mensaje
news:

y solucion a ese manejo de listas cual es amigo?



"Alberto Poblacion" wrote
in message news:

"CSharp" wrote in message
news:
> Se me esta presentando un problema al intentar manipular varias listas

en

> una misma funcion.
> El problema es el siguiente:
> Tengo
> List<Objeto> lista1 = new List<Objeto>();
> List<Objeto> lista2 = new List<Objeto>();
> lista1.Add(Objeto1);
> lista1.Add(Objeto2);
> lista1.Add(Objeto3);
> lista2 = lista1;
> lista1.Clear();
>
> En lo anterior, se llena la lista1 con tres objetos, y luego asigno
> esta
> lista1 a la lista2, entonces ambas listas (lista1 y lista2) deben ser
> iguales. Pero al ejecutar el metodo Clear() a la lista1, tambien afecta

la

> lista2, quedando finalmente ambas listas vacias.
>
> Que esta ocurriendo? y como puedo solucionarlo??

Estás confundiendo el comportamiento de las variables de tipo

Referencia

con el de las variables de tipo Valor. Cuando haces variable1=variable2 y
las dos variables son de tipo Valor (por ejemplo, son "int"), entonces
variable2 se copia en variable1, y las dos copias son independientes.
Pero cuando las variables son de tipo Referencia, no contienen
directamente los datos, sino que los datos se asignan en una zona de

memoria

separada, denominada el Heap. Al hacer el "new", se asigna memoria en el
Heap, y dentro de la variable lo único que se guarda es una especie de
"puntero" (que se llama Referencia) que apunta a esa memoria reservada en

el

Heap. Cuando haces variable1=variable2, lo que se copia es la referencia,
pero no se copia toda la memoria que hay en el Heap y que contiene los
datos. Asi pues, despues de hacer la copia, las dos variables señalan al
mismo area de memoria, y por lo tanto los datos que modificas a partir de
una se ven modificados en la otra.

Veamos lo que hacen tus sentencias:

> List<Objeto> lista1 = new List<Objeto>();
Se asigna espacio en el Heap para contener un List<Objeto>, y la
referencia a dicho espacio (llamémosle espacio1) se guarda en lista1.

> List<Objeto> lista2 = new List<Objeto>();
Se asigna espacio en el Heap para contener un List<Objeto>, y la
referencia a dicho espacio (llamémosle espacio2) se guarda en lista2.

> lista1.Add(Objeto1);
> lista1.Add(Objeto2);
> lista1.Add(Objeto3);
Se han metido 3 objetos en el espacio1.

> lista2 = lista1;
Se copia la referencia al espacio1 dentro de lista2. Ahora ya no

existe

ninguna referencia al espacio2, por lo que éste es inalcanzable y queda
disponible para ser destruido por el Garbage Collector.

> lista1.Clear();
Se vacía todo lo que había en la zona a la que apunta lista1, es

decir,

el espacio1.

Si ahora pides el contenido de lista2, como apunta al espacio1 y lo

acabamos

de vaciar, te dice que no contiene nada.

"CSharp" wrote in message
news:

y solucion a ese manejo de listas cual es amigo?

Desgraciadamente, el List<T> no es ICloneable, así que, si quieres una
copia, tienes que sacarla a mano. En lugar de hacer lista2=lista1, tienes
que hacer algo parecido a esto:

lista2 = new List<Objeto>();
foreach (Objeto o in lista1) lista2.Add(o);

Nótese que, aunque ahora las dos listas tienen una asignación de memoria
distinta, volvemos a tener el mismo problema con los _objetos_ que hay
dentro de la lista. Es decir, cada objeto solo existe una vez, y lo que
ocurre es que cada una de las dos listas contiene una referencia al mismo
objeto. Si no es ese el efecto deseado, hay que repetir el proceso entrando
dentro de cada uno de los objetos y copiando las partes que lo componen. La
forma "estandarizada" de hacer esto consiste en implementar en los objetos
el interaz ICloneable, el cual declara una función Clone() cuya
implementación está previsto que realice una copia del contenido del objeto.
Esa función Clone sería la que llamarías al copiar la lista:

lista2 = new List<Objeto>();
foreach (Objeto o in lista1) lista2.Add(((ICloneable)o).Clone());

y solucion a ese manejo de listas cual es amigo?



"Alberto Poblacion" wrote
in message news:

"CSharp" wrote in message
news:
> Se me esta presentando un problema al intentar manipular varias listas

en

> una misma funcion.
> El problema es el siguiente:
> Tengo
> List<Objeto> lista1 = new List<Objeto>();
> List<Objeto> lista2 = new List<Objeto>();
> lista1.Add(Objeto1);
> lista1.Add(Objeto2);
> lista1.Add(Objeto3);
> lista2 = lista1;
> lista1.Clear();
>
> En lo anterior, se llena la lista1 con tres objetos, y luego asigno esta
> lista1 a la lista2, entonces ambas listas (lista1 y lista2) deben ser
> iguales. Pero al ejecutar el metodo Clear() a la lista1, tambien afecta

la

> lista2, quedando finalmente ambas listas vacias.
>
> Que esta ocurriendo? y como puedo solucionarlo??

Estás confundiendo el comportamiento de las variables de tipo

Referencia

con el de las variables de tipo Valor. Cuando haces variable1=variable2 y
las dos variables son de tipo Valor (por ejemplo, son "int"), entonces
variable2 se copia en variable1, y las dos copias son independientes.
Pero cuando las variables son de tipo Referencia, no contienen
directamente los datos, sino que los datos se asignan en una zona de

memoria

separada, denominada el Heap. Al hacer el "new", se asigna memoria en el
Heap, y dentro de la variable lo único que se guarda es una especie de
"puntero" (que se llama Referencia) que apunta a esa memoria reservada en

el

Heap. Cuando haces variable1=variable2, lo que se copia es la referencia,
pero no se copia toda la memoria que hay en el Heap y que contiene los
datos. Asi pues, despues de hacer la copia, las dos variables señalan al
mismo area de memoria, y por lo tanto los datos que modificas a partir de
una se ven modificados en la otra.

Veamos lo que hacen tus sentencias:

> List<Objeto> lista1 = new List<Objeto>();
Se asigna espacio en el Heap para contener un List<Objeto>, y la
referencia a dicho espacio (llamémosle espacio1) se guarda en lista1.

> List<Objeto> lista2 = new List<Objeto>();
Se asigna espacio en el Heap para contener un List<Objeto>, y la
referencia a dicho espacio (llamémosle espacio2) se guarda en lista2.

> lista1.Add(Objeto1);
> lista1.Add(Objeto2);
> lista1.Add(Objeto3);
Se han metido 3 objetos en el espacio1.

> lista2 = lista1;
Se copia la referencia al espacio1 dentro de lista2. Ahora ya no

existe

ninguna referencia al espacio2, por lo que éste es inalcanzable y queda
disponible para ser destruido por el Garbage Collector.

> lista1.Clear();
Se vacía todo lo que había en la zona a la que apunta lista1, es

decir,

el espacio1.

Si ahora pides el contenido de lista2, como apunta al espacio1 y lo

acabamos

de vaciar, te dice que no contiene nada.

En lugar de:

lista2 = lista1;

deberías usar:

lista2 = new List<Objeto>(lista1.ToArray());


Saludos,
Pedro Luna




"CSharp" escribió en el mensaje de
noticias:

y solucion a ese manejo de listas cual es amigo?



"Alberto Poblacion" wrote
in message news:

"CSharp" wrote in message
news:
> Se me esta presentando un problema al intentar manipular varias listas

en

> una misma funcion.
> El problema es el siguiente:
> Tengo
> List<Objeto> lista1 = new List<Objeto>();
> List<Objeto> lista2 = new List<Objeto>();
> lista1.Add(Objeto1);
> lista1.Add(Objeto2);
> lista1.Add(Objeto3);
> lista2 = lista1;
> lista1.Clear();
>
> En lo anterior, se llena la lista1 con tres objetos, y luego asigno
> esta
> lista1 a la lista2, entonces ambas listas (lista1 y lista2) deben ser
> iguales. Pero al ejecutar el metodo Clear() a la lista1, tambien afecta

la

> lista2, quedando finalmente ambas listas vacias.
>
> Que esta ocurriendo? y como puedo solucionarlo??

Estás confundiendo el comportamiento de las variables de tipo

Referencia

con el de las variables de tipo Valor. Cuando haces variable1=variable2 y
las dos variables son de tipo Valor (por ejemplo, son "int"), entonces
variable2 se copia en variable1, y las dos copias son independientes.
Pero cuando las variables son de tipo Referencia, no contienen
directamente los datos, sino que los datos se asignan en una zona de

memoria

separada, denominada el Heap. Al hacer el "new", se asigna memoria en el
Heap, y dentro de la variable lo único que se guarda es una especie de
"puntero" (que se llama Referencia) que apunta a esa memoria reservada en

el

Heap. Cuando haces variable1=variable2, lo que se copia es la referencia,
pero no se copia toda la memoria que hay en el Heap y que contiene los
datos. Asi pues, despues de hacer la copia, las dos variables señalan al
mismo area de memoria, y por lo tanto los datos que modificas a partir de
una se ven modificados en la otra.

Veamos lo que hacen tus sentencias:

> List<Objeto> lista1 = new List<Objeto>();
Se asigna espacio en el Heap para contener un List<Objeto>, y la
referencia a dicho espacio (llamémosle espacio1) se guarda en lista1.

> List<Objeto> lista2 = new List<Objeto>();
Se asigna espacio en el Heap para contener un List<Objeto>, y la
referencia a dicho espacio (llamémosle espacio2) se guarda en lista2.

> lista1.Add(Objeto1);
> lista1.Add(Objeto2);
> lista1.Add(Objeto3);
Se han metido 3 objetos en el espacio1.

> lista2 = lista1;
Se copia la referencia al espacio1 dentro de lista2. Ahora ya no

existe

ninguna referencia al espacio2, por lo que éste es inalcanzable y queda
disponible para ser destruido por el Garbage Collector.

> lista1.Clear();
Se vacía todo lo que había en la zona a la que apunta lista1, es

decir,

el espacio1.

Si ahora pides el contenido de lista2, como apunta al espacio1 y lo

acabamos

de vaciar, te dice que no contiene nada.