[ Foro de C# ]
no puedo recuperar el valor almacenado en esta propiedad, lo que me manda es esto
"System.Collections.Generic.List`1[Default2+Bloque]"
en lugar de eso deberia de mostrarme el numero "1" pero no es asi
que tendria que hacer para que me muestre lo que quiero?
class Bloque
{
public int tamaño { get ;set; }
}
protected void Page_Load(object sender, EventArgs e)
{
var lista = new List<Bloque>();
Bloque b = new Bloque();
b.tamaño = 1;
lista.Add(b);
Response.Write(lista);
Claro. No puedes mostrar toda una lista en pantalla. Tendrás que recorrer sus elementos uno a uno (con "for" o "foreach", por ejemplo), para mostrarlos uno a uno (para eso, necesitarás que cada elemento tenga definido un "ToString").
Aparte de eso, en tu programa veo otra cosa peligrosa: dentro de un método de la clase Bloque estás creando un objeto de la clase Bloque (realmente una lista de Bloques)... eso puede dar lugar a recursividad indirecta y bloquear el programa o hacerlo fallar.
hola, pude sacarlo pero no estoy seguro si esto me sirva para lo que quiero
es la misma temática de un tema que hice referente a lo mismo que intento hacer
hay datos almacenados mayores a cero e iguales a cero
y lo que quiero es almacenar en bloques los valores almacenados mayores a cero y los iguales para hacer un estilo de barra de progreso donde mostrare en rojo los que están en cero y en verde los que son mayores,
y estoy utilizando un while para esto :
mientras el valor que se esta leyendo sea mayor a cero que almacene +1 que significa que un intervalo sera en verde y no se si pueda hacer otro while donde haga lo mismo pero en ceros
la idea es que estos bloques representen lo que quiero lograr a hacer ya tengo mas de 3 semanas estudiando, leyendo y encontré esta manera lo cual lo veo mas viable para poder dar fin a mi proyecto
dejo el codigo en donde no logré hacer lo que quiero
MIENTRAS "n" sea menor a 50 hará lo que viene dentro de la instruccion y fuera muestra las acumulaciones
public class Bloque
{
public int Medida { get; set; }
}
protected void Page_Load(object sender, EventArgs e)
{
var Lista = new List<Bloque>();
int n = 1;
while (n < 50)
{
n++;
Bloque bloque = new Bloque();
bloque.Medida = n;
Lista.Add(bloque);
}
// Image1.Width = Lista.Count;
Response.Write(Lista.Count);
}
solo que al integrarlo a mi proyecto no me funciona marca un error en "Lista.add(bloque);
while (cliente.Intervalos > 0) intervalos es el campo en una tabla donde se almacenan los valores a evaluar mientras ellos sean mayores a cero harán lo que se le pide
var Lista = new List<Bloque>();
int n = 1;
foreach (var cliente in Factory.Clientes.GetDetalles(IdCliente, Mes))
{
while (cliente.Intervalos > 0)
{
n++;
Bloque bloque = new Bloque();
bloque.Medida = n;
Lista.Add(bloque);
}
}
Image1.Width = Lista.Count;
Response.Write(Lista.Count);
La línea del Add no debería dar error, la sintaxis parece correcta.
Lo que no entiendo es la lógica que le rodea: eso de que un bloque contenga una lista de bloques, no eso de añadir exactamente 50 elementos y aun así hacer un contador y usar eso para saber la anchura de la imagen (que siempre será 50)
hola lo que intento hacer es que cada bloque se almacene una cantidad de numeros enteros lo cual seran los pixeles de la barra, y lo que intento hacer es que cada numero mayor a cero valga un +1 y se sume a un bloque e cuando valga 0 se sume a otro bloque cada bloque representara un valor que hara que la barra se llene y cuando el valor sea mayor a cero se marcara en verde y cuando sea igual a cero se marcara en rojo
aqui dejo el codigo e avanzado poco, los valores de la tabla los estoy representando como si fuera una matriz en este ejemplo: aqui se ve que hay almacenados varios en cero y mayores a cero lo cual lo que deceo hacer es que cuando el valor sea igual a cero se haga otro bloque en donde se almacene un +1 en ese bloque mientras dure los numeros en cero y asi continuaria el ciclo dejo la matriz
int[] numbers = { 4, 5, 6, 6,0,0,0,1,0,2,0,2 };
entonces asi seria como al inicio hay 4 numeros mayores a cero seria +1 en cada uno lo que daria 4 y los otros que estan en cero serian 3 y asi sucecibamente entonces quedaria algo como esto: 4,(3),1,(1),1,(1),1.
los que estan entre parentecis representarian los valores menores a cero lo que equivaldria a el numero de pixeles que abarcaran en la barra que quiero hacer y en representacion grafica seria
4 verdes,(3rojos),1verde,(1rojo),1verde,(1rojo),1verde y lo que continue
dejo lo que llevo no se si voy por buen camino o de plano no...
y dejo un enlace de una imagen de como quiero representarlo dejare el enlace al final
public class Bloque
{
public int Medida { get; set; }
public int Medida2 { get; set; }
}
private void ejemplo (int IdCliente,int Mes)
{
var Lista = new List<Bloque>();
var Lista2 = new List<Bloque>();
int[] numbers = { 4, 5, 6, 6,0,0,0,1,0,2,0,2 };
int n = 0;
int m = 0;
foreach (int i in numbers)
{
if(i>0){
n++;
Bloque Tamaño = new Bloque();
Tamaño.Medida = n;
Lista.Add( new Bloque());
}
else
{
m++;
Bloque Tamaño2 = new Bloque();
Tamaño2.Medida2 = m;
Lista2.Add(Tamaño2);
}
}
https://fbcdn-sphotos-e-a.akamaihd.net/hphotos-ak-xfa1/v/t1.0-9/11070961_1093378520688652_6232044927797627459_n.jpg?oh=0e7ab66d82d06f77a2989a6be0fba032&oe=55ACE57F&__gda__=1441066228_90677fde6c7d5d940babd326b60ac89b
Vale, creo que ahora entiendo a lo que te refieres.
Se trata de ver el tamaño de secuencias. Cuando haya varios números positivos seguidos, eso es una secuencia, y quieres ver cuántos números la forman. Cuando encuentras un cero, pasa a ser una nueva secuencia, de la que también querrás ver cuántos números la forman (la cantidad de ceros que hay seguidos), y así sucesivamente.
¿Es así?
es correcto, es lo que intento hacer
En ese caso, vamos a simplificar el problema primero.
Vamos a olvidar por un momento tu clase "Bloque" y vamos a centrarnos en crear un programa que te muestre cuantos positivos y cuantos ceros va encontrando, para que veas cómo podría ser la lógica de un contador doble si tienes dos estados posible.
Podría ser así:
using System;
public class ContarPositivosYCeros
{
public static void Main()
{
int[] numbers = { 4, 5, 6, 6, 0, 0, 0, 1, 0, 2, 3, 0, 2 };
bool enCeros = false;
bool enPositivos = false;
int contadorPositivos = 0;
int contadorCeros = 0;
// Miramos el primer valor
if (numbers[0] > 0)
enPositivos = true;
else
enCeros = false;
// Y recorremos todos ellos
foreach (int n in numbers)
{
// Si estamos con positivos y llega otro, contamos
if (enPositivos && (n > 0))
{
contadorPositivos ++;
}
// Lo mismo si estamos con ceros y llega otro cero
else if (enCeros && (n == 0))
{
contadorCeros++;
}
// Si cambia de positivos a cero, mostramos y cambiamos estado
else if (enPositivos && (n == 0))
{
Console.WriteLine("P"+contadorPositivos+" ");
enPositivos = false;
enCeros = true;
contadorPositivos = 0;
contadorCeros = 1;
}
// Y similar si cambia de ceros a positivos
else if (enCeros && (n > 0))
{
Console.WriteLine("C"+contadorCeros+" ");
enPositivos = true;
enCeros = false;
contadorCeros = 0;
contadorPositivos = 1;
}
}
// Finalmente, faltará mostrar el último bloque
if (contadorCeros > 0)
Console.WriteLine("C"+contadorCeros+" ");
else
Console.WriteLine("P"+contadorPositivos+" ");
}
}
Se podría simplificar un poco, usando un único booleano (porque son excluyentes: o estás recorriendo un bloque de positivos o uno de ceros), pero esto debería ayudarte a entender una lógica que luego adaptar a tu programa concreto.
(No se puede continuar esta discusión porque tiene más de dos meses de antigüedad. Si tienes dudas parecidas, abre un nuevo hilo.)