Archivos y flujos

Introducción
Las variables y los arreglos ofrecen solo un almacenamiento temporal de los datos; los datos se pierden cuando una variable local queda fuera de alcance o un programa termina. Los archivos y las bases de datos se utilizan para una retención a largo plazo de cantidades grandes de datos.
Jerarquía de datos
Todos los elementos de datos que procesan los computadores se reducen a combinaciones de 0 y de 1. El elemento más pequeño de datos que soporta las computadoras es el digito binario (bit).
Los elementos de datos procesados por las computadoras Los elementos de datos procesados por las computadoras Los elementos de datos procesados por las computadoras forman una jerarquía de datos en la cual los elementos se hacen mas grande y complejos en estructura a medida que progresamos de bits caracteres, de caracteres a campos y de campos hasta llegar a conjuntos de datos mas grandes.
C# considera cada archivo como flujo secuencial de bytes, cuando se abre un archivo se crea un objeto que se asocia con un flujo, existen muchas clases de procesamiento de archivos en FCL, el espacio de nombres System.IO, incluye flujos como StreamReader, StreamWriter y FIleStream.
Estas clases de flujos heredan de las clases Abstract, TextReader, TextWriter y Stream .
Las clases File y Directory
Las clases File puede determinar información acerca de los archivos y puede usarse para abrir archivos en modo de lectura o de escritura, la clase Directory cuenta con herramientas para manipular directorios, el objeto DirectoryInfo devuelto por el método create, Directory contiene información acerca de un directorio, gran parte de la información contenida de la clase DirectoryInfo, también puede utilizarse a través de los métodos de la clase Directory.
Creación de un archivo de texto de acceso secuencial
El programa C# no impone una estructura en los archivos, esto significa que debe estructurar los archivos para cumplir con los requerimientos de sus aplicaciones.
Lectura de datos desde un archivo de texto de acceso secuencial
La clase LeerArchivoAccesoSecuencial lee registros del archivo creado por el programa y después muestra el contenido de cada registro.
Búsqueda de un archivo de acceso secuencial
Para recuperar los datos en forma secuencial de un archivo, lo común es que un programa empiece desde el principio del archivo, leyendo en forma consecutiva hasta los datos deseados. Algunas veces es necesario procesar un archivo en forma secuencial varias veces a cualquier posición en el archivo, cuando se abre un objeto FileStream, su apuntador de posición se establece de posición se establece a la posición byte 0.
Serielización
Un objeto serializado se presenta como una secuencia de bytes que incluye los datos de ese ejemplo así como información acerca del tipo del objeto. Una vez que se escribe un objeto serializado en un archivo, puede leerse desde ese archivo y deserializarse; esto es la información sobre el tipo y los bytes que representan al objeto y sus datos pueden usarse para recrear el objeto en la memoria. La clase BinaryFormatter permite escribir o leer objetos completos en/desde un flujo. El método Serialize de BinaryFormatter leer esta representación de un archivo y reconstruye el objeto original. Ambos métodos lanzan una excepción SerializationExeption si ocurre un error durante la serielización o la deserializacion ambos métodos requieren un objeto stream como parámetro para que el objeto BinaryFormatter pueda acceder al flujo correcto.
Creación de un archivo de acceso secuencial mediante el uso de la serielización de objetos
Clase RegistroSerializable:
En una clase marcada con el atributo Serializable o que implementa la interfaz ISerializable, debemos asegurarnos que toda variable de instancia de la clase también sea serializable. Todas las variables simples y los objetos string son serializables. Para las variables de tipos por referencia, hay que comprobar la declaración de la clase para asegurarnos que el tipo sea serializable, los objetos tipo arreglo son serializables de manera predeterminada, no obstante, si el arreglo contiene referencias a otros objetos, estos podrían no ser o ser serializables.


Ejemplo
using System;
using System.Windows.Forms;
using System.IO;
usiyng BibliotecaBanco;

public partial class LeerArchivosAccesoSecuencialForm : BancoUIForm
{
private FileStream entrada;
private StreamReader archivoReader;
public LeerArchivoAccesoSecuencialForm();
{
InitializeComponent();
}
private void abrirButton:Click(object sender, EventArgs e )
{
OpenFileDialog selectorArchivo ? new OpenFileDialog();
DialogResult resultado = selectorArchivo.ShowDialog();
string nombreArchivo;
if(resultado== DialogResult.Cancel)
return;
nombreArchivo=selectoeArchivo.FileName;
BorrarControlesTextBox();
if(nombreArchivo==""||nombreArchivo==null)
MessageBox.Show("Nombre de archivo invalido", "Error", MessageBoxButtons.Ok, MessajeBoxIcon.Error);
else
{
entrada = nue FileStream(nombreArchivo, FileMode, Open, FileAccess.Read);
archivoReader = new StreamReader(entrada);
abrirButton.Eneabled = false;
siguienteButton.Eneabled= true;
}
}
private void siguienteButton_Click(object sender, EventArgs e)
{
try
{
string registroEntrada = archivoReader.ReadLine();
string [] camposEntrada;
if(registroEntrada!=null)
{camposEntrada=registroEntrada.Split(',');
Registro registro = new Registro(Convert.toInt31(camposEntrada[0], camposEntrada[1], camposEntrada[2],Convert.ToDecimal( camposEntrada[3]));
EstrablecerValoresControlesTextBox(camposEntrada);
}
else
{
archivoReader.Close();entrada.Close();
abrirButton.Eneabled = true;
siguienteButton.Eneabled= false;
BorrarControlesTextBox();

MessageBox.Show("No hay mas registros en el archivo", "", MessageBoxButtons.OK, MessajeBoxIcon.Information);
}
}
catch(IOException)
{
MessageBox.Show( "Error al leer del archivo", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}

ejemplo del resumen

class Program
{
static void Main(string[] args);

private static void guardarTexto437()
{
const string fic = @"E:\tmp\Prueba4.txt";
string texto = "Érase una vez una vieja con un moño...";

System.IO.StreamWriter sw = new System.IO.StreamWriter(fic, false, System.Text.Encoding.GetEncoding(437));
sw.WriteLine(texto);
sw.Close();
}


private static void leerTexto437()
{
const string fic = @"E:\tmp\Prueba4.txt";
string texto;

System.IO.StreamReader sr = new System.IO.StreamReader(fic, System.Text.Encoding.GetEncoding(437), true);
texto = sr.ReadToEnd();
sr.Close();

Console.WriteLine(texto);
}
}
}

9.4 codigo

class ArregloBidimensional
{
int[,] Tabla;
int IndiceRenglon;
int IndiceColumna;
int I, J;
public ArregloBidimensional()
{
Tabla = new int[1000, 1000];
}
public ArregloBidimensional(int N, int M)
{
Tabla = new int[N, M];
IndiceRenglon = 0;
IndiceColumna = 0;
}
public void IntroduceDato(int R, int C, int X)
{
Tabla[R, C] = X;
}
public int ObtenerDato(int R, int C)
{
return tabla[R, C];
}
public int[,] tabla
{
get { return Tabla; }
set { Tabla = value; }
}
public int IndRenglon
{
get { return IndiceRenglon; }
set { IndiceColumna = value; }
}
public int IndColumna
{
get { return IndiceColumna; }
set { IndiceRenglon = value; }
}
public int SumaRenglon(int R, int NC)
{
int Suma = 0;
int I;
for (I = 0; I < NC; I++)
{
Suma = Suma + Tabla[R, I];
}
return Suma;
}
public int SumaColumna(int NR, int C)
{
int Suma = 0;
int I;
for (I = 0; I < NR; I++)
{
Suma = Suma + Tabla[I, C];
}
return Suma;
}
public int SumaTotal(int N, int M)
{
int I, J;
int Suma = 0;
for (I = 0; I < N; I++)
{
for (J = 0; J < M; J++)
{
Suma = Suma + Tabla[I, J];
}
}
return Suma;
}
public double Mayor(int N, int M)
{
double May = 0;
int AveMay = 0;
int CalleMay = 0;

for (I = 0; I < N; I++)
{
for (J = 0; J < M; J++)
{
if (Tabla[I, J] > May)
{
May = Tabla[I, J];
AveMay = I;
CalleMay = J;
}
}
}
IndiceRenglon = AveMay;
IndiceColumna = CalleMay;
return May;


}
}
}


class Program
{
static void Main(string[] args)
{
int sigue, Ave, Calle, Acc;
ArregloBidimensional Reticula = new ArregloBidimensional(10, 29);
do
{
Console.WriteLine("Registro de incidentes");
Console.WriteLine(" Numero de avenida");
Ave = int.Parse(Console.ReadLine());
Console.WriteLine("Numero de Calle");
Calle = int.Parse(Console.ReadLine());
Console.WriteLine("Numero de Accidentes");
Acc = int.Parse(Console.ReadLine());
Reticula.IntroduceDato(Ave - 1, Calle - 30, Acc);
Console.WriteLine("Presione 1 para continuar");
sigue = int.Parse(Console.ReadLine());
}
while (sigue == 1);
double PrimerMayor = Reticula.Mayor(10, 29);
int PrimerIndice_R = Reticula.IndRenglon;
int PrimerIndice_C = Reticula.IndColumna;
Reticula.tabla[PrimerIndice_R, PrimerIndice_C] = 0;
double SegundoMayor = Reticula.Mayor(10, 29);
int SegundoIndice_R = Reticula.IndRenglon;
int SegundoIndice_C = Reticula.IndColumna;
Reticula.tabla[SegundoIndice_R, SegundoIndice_C] = 0;
double TerceroMayor = Reticula.Mayor(10, 29);
int TerceroIndice_R = Reticula.IndRenglon;
int TerceroIndice_C = Reticula.IndColumna;
Console.WriteLine("El primer mayor es {0}, esta en la avenida {1} y la calle {2}", PrimerMayor, PrimerIndice_R + 1, PrimerIndice_C + 30);
Console.WriteLine("El segundo mayor es {0}, esta en la avenida {1} y la calle {2}", SegundoMayor, SegundoIndice_R + 1, SegundoIndice_C + 30);
Console.WriteLine("El tercero mayor es {0}, esta en la avenida {1} y la calle {2}", TerceroMayor, TerceroIndice_R + 1, TerceroIndice_C + 30);
Console.ReadLine();




}
}
}

practica 9.4

9.3 codigo

class ArregloBidimensional
{

int[,] tabla;
public ArregloBidimensional(int N, int M)
{
tabla = new int[N, M];
}
public void AsignarDato(int R, int C, int X)
{
tabla[R, C] = X;
}
public int ObtenerDato(int I, int J)
{
return tabla[I, J];
}
public int[,] T1
{
get { return tabla; }
set { tabla = value; }
}
public int SumaRengllon(int R, int NC)
{
int suma = 0;
int I;

for (I = 0; I < NC; I++)
{
suma = suma + tabla[R, I];
}
return suma;
}
public int SumaColumna(int NR, int C)
{
int suma = 0;
int I;
for (I = 0; I < NR; I++)
{
suma = suma + tabla[I, C];
}
return suma;
}
public int SumaTotal(int N, int M)
{
int I;
int suma = 0;
for (I = 0; I < N; I++)
{
suma = suma + SumaRengllon(I, M);
}
return suma;
}
}
}


class Arreglo
{
double[] Elemento;
public Arreglo()
{
Elemento = new double[12];

}
public Arreglo(int N)
{
Elemento = new double[N];
}
public void introducirDato(int J, double X)
{
Elemento[J] = X;
}
public void AcumularDato(int J, double X)
{
Elemento[J] = Elemento[J] + X;
}
public double ObtenerDato(int J)
{
return Elemento[J];
}
public double[] elemento
{
get { return Elemento; }

set { Elemento = value; }
}
public double suma(int N)
{
int I;
double sum = 0.0;
for (I = 0; I < N; I++)
{
sum = sum + Elemento[I];
}
return sum;
}
}
}



class Program
{
static void Main(string[] args)
{
int R, C, valor, N, M;
double suma;
Console.WriteLine(" Introduce numero de filas");
M = int.Parse(Console.ReadLine());
Console.WriteLine("Introduce numero de columnas");
N = int.Parse(Console.ReadLine());
ArregloBidimensional A = new ArregloBidimensional(M, N);
Arreglo X = new Arreglo(N);
Arreglo Y = new Arreglo(M);
for (R = 0; R < M; R++)
{
for (C = 0; C < N; C++)
{
Console.Write("Introduce el valor A [{0},{1}]: ", (R + 1), (C + 1));
valor = int.Parse(Console.ReadLine());
A.T1[R, C] = valor;
}
}
Console.WriteLine("Introduce los siguientes valores");
for (C = 0; C < N; C++)
{
Console.Write("X[{0}]:", (C + 1));
valor = int.Parse(Console.ReadLine());
X.introducirDato(C, valor);
}
for (R = 0; R < M; R++)
{
suma = 0.0;
for (C = 0; C < N; C++)
{
suma = suma + A.T1[R, C] * X.ObtenerDato(C);

}
Y.elemento[R] = suma;
}
for (R = 0; R < M; R++)
{
for (C = 0; C < N; C++)
{
Console.WriteLine("Valor [{0},{1}] = {2}", (R + 1), (C + 1), A.ObtenerDato(R, C));
}
}
for (C = 0; C < N; C++)
{
Console.WriteLine("Valor de X[{0}] = {1}", (C + 1), X.ObtenerDato(C));
}
for (R = 0; R < M; R++)
{
Console.WriteLine("Valor Y[{0}] = {1}", (R + 1), Y.ObtenerDato(R));
}
Console.ReadLine();

}
}
}

practica 9.3

9.2 codigo

public partial class Form1 : Form
{
Arreglo Articulos = new Arreglo();
ArregloBidimensional Ventas = new ArregloBidimensional(20, 50);
int Num, NumArt, Ven;

public Form1()
{
InitializeComponent();
}

private void button2_Click(object sender, EventArgs e)
{
Num = int.Parse(textBox1.Text);

NumArt = int.Parse(textBox2.Text);

Ven = int.Parse(textBox3.Text);
Ventas.tabla[(Num - 1), (NumArt - 1)] = Ven;
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox1.Focus();


}

private void button1_Click(object sender, EventArgs e)
{
listBox1.Items.Add("Calculo de Sueldo");
listBox1.Items.Add(" Numero Vendedor Total de Venta Sueldo");
int R, C;
double sum, sueldo;
for (R = 0; R < 20; R++)
{
sum = 0.0;
for (C = 0; C < 50; C++)
{
sum = sum + Ventas.ObtenerDato(R, C) * Articulos.ObtenerDato(C);
}
sueldo = sum * 0.05;
listBox1.Items.Add("\t" + (R + 1) + "\t\t" + sum + "\t\t" + sueldo);
}
}
}
}

class ArregloBidimensional
{
int[,] Tabla;
public ArregloBidimensional()
{
Tabla = new int[1000, 1000];
}
public ArregloBidimensional(int N, int M)
{
Tabla = new int[N, M];
}
public void IntroduceDato(int R, int C, int X)
{
Tabla[R, C] = X;
}
public int ObtenerDato ( int R, int C)
{
return Tabla[R,C];
}
public int[,] tabla
{
get { return Tabla; }
set { Tabla = value; }
}
public int SumaRenglon(int R, int NC)
{
int sum = 0;
int I;
for (I = 0; I < NC; I++)
{
sum = sum + Tabla[R, I];
}
return sum;
}
public int SumaColumna(int NR, int C)
{
int sum = 0;
int I;
for (I = 0; I < NR; I++)
{
sum = sum + Tabla[I, C];
}
return sum;
}
public int SumaTotal(int N, int M)
{
int I,J;
int sum = 0;
for (I = 0; I < N; I++)
{
for (J = 0; J < M; J++)
{
sum = sum + Tabla[I,J];
}
}
return sum;
}
}
}



class Arreglo
{
double[] Elementos;
public Arreglo()
{
Elementos = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50 };
}
public double[] elemento
{
get { return Elementos; }
set { Elementos = value; }
}
public void AsignarDato(int J, int X)
{
Elementos[J] = X;
}
public double ObtenerDato(int j)
{
return Elementos[j];
}
}
}

practica 9.2 visual

9.1 codigo

public partial class Form1 : Form
{
ArregloBidimensional MATRIZ = new ArregloBidimensional();

int I = 0, J = 0;
int A, B;
int C = 1;
int D = 0;
public Form1()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
textBox2.Enabled = false;
textBox4.Enabled = false;
button1.Enabled = false;
textBox3.Focus();
}

private void button2_Click(object sender, EventArgs e)
{
int NC, NR;
textBox3.Focus();
NR = int.Parse(textBox2.Text);
NC = int.Parse(textBox4.Text);

if (I == (NR - 1) && J == (NC - 1))
{
A = int.Parse(textBox3.Text);
MATRIZ.IntroduceDato(NR - 1, NC - 1, A);
B = MATRIZ.SumaTotal(NR, NC);

listBox1.Items.Add("Suma total es:" + B);
label3.Text = ("MATRIZ[" + (NR) + "," + (NC) + "]:");
for (I = 0; I < NR; I++)
{

listBox1.Items.Add("Suma de renglon " + (I + 1) + " = " + MATRIZ.SumaRenglon(I, NC));
}
for (J = 0; J < NC; J++)
{
listBox1.Items.Add("Suma de columna " + (J + 1) + " = " + MATRIZ.SumaColumna(NR, J));
}
label3.Visible = false;
textBox3.Enabled = false;
button2.Enabled = false;


}
if (J == (NC))
{
J = 0;
I++;

}
if (C == NC)
{
C = 0;
D++;
}
if (J < NC)
{
if ((I == (NR - 1) && J == (NC - 1)))
{
label3.Text = ("MATRIZ[" + (D + 1) + "," + (C + 1) + "]:");
MATRIZ.tabla[I, J] = int.Parse(textBox3.Text);
C++;
J++;
}
else
{
label3.Text = ("MATRIZ[" + (D + 1) + "," + (C + 1) + "]:");
MATRIZ.tabla[I, J] = int.Parse(textBox3.Text);
C++;
J++;
textBox3.Clear();
}
}
}
}
}



class ArregloBidimensional
{
int[,] Tabla;
public ArregloBidimensional()
{
Tabla = new int[1000, 1000];
}
public ArregloBidimensional(int N, int M)
{
Tabla = new int[N, M];
}
public void IntroduceDato(int R, int C, int X)
{
Tabla[R, C] = X;
}
public int ObtenerDato ( int R, int C)
{
return tabla[R,C];
}
public int[,] tabla
{
get { return Tabla; }
set { Tabla = value; }
}
public int SumaRenglon(int R, int NC)
{
int Suma = 0;
int I;
for (I = 0; I < NC; I++)
{
Suma = Suma + Tabla[R, I];
}
return Suma;
}
public int SumaColumna(int NR, int C)
{
int Suma = 0;
int I;
for (I = 0; I < NR; I++)
{
Suma = Suma + Tabla[I, C];
}
return Suma;
}
public int SumaTotal(int N, int M)
{
int I,J;
int Suma = 0;
for (I = 0; I < N; I++)
{
for (J = 0; J < M; J++)
{
Suma = Suma + Tabla[I,J];
}
}
return Suma;
}
}
}

practica 9.1

practica 8.3 vis

public partial class Form1 : Form
{
int Numero;
string name;
double total;
Vendedor[] compañia = new Vendedor[25];
Arreglo Vmax = new Arreglo(25);

public Form1()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
Numero = int.Parse(textBox1.Text);


name = textBox2.Text;

total = double.Parse(textBox3.Text);

Vendedor VX = new Vendedor(Numero, name, total);
compañia[Numero - 1] = VX;
Vmax.AsignarDato((Numero), total);
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox1.Focus();
}

private void button2_Click(object sender, EventArgs e)
{
listBox1.Items.Add("Numero de Vendedor Nombre Vendedor Total de Venta");
int I;
for (I = 0; I < 25; I++)
{
if (compañia[I] != null)
{
listBox1.Items.Add(compañia[I].no_vend + "\t" + compañia[I].nombre + "\t" + compañia[I].totalventa);
}
}
int Posmay = Vmax.Mayor(25);
listBox1.Items.Add("");
listBox1.Items.Add("Numero de vendedor " + compañia[Posmay - 1].no_vend + ", nombre " + compañia[Posmay - 1].nombre + " ,venta mayor " + Vmax.ObtenerDato(Posmay));
int a = 0;
Vmax.AsignarDato(Posmay, a);
Posmay = Vmax.Mayor(25);
listBox1.Items.Add("");
listBox1.Items.Add("Numero de vendedor " + compañia[Posmay - 1].no_vend + ", nombre " + compañia[Posmay - 1].nombre + " ,venta mayor 2 " + Vmax.ObtenerDato(Posmay));


}
}
}




class Arreglo
{



double[] valores;

int I;
public Arreglo()
{
valores = new double[10];
}
public Arreglo(int N)
{
valores = new double[N];

}
public void AsignarDato(int J, double nuevoDato)
{
valores[J] = nuevoDato;
}

public double ObtenerDato(int J)
{
return valores[J];
}
public int Mayor(double N)
{
double May = valores[0];
int Pos = 0;
for (I = 0; I < N; I++)
{
if (valores[I] > May)
{
May = valores[I];
Pos = I;
}
}
return Pos;
}
}
}

8.3 vis

8.3 clase

class Vendedor
{

int NoVend;
string Nombre;
double TotalVenta;

public Vendedor()
{
NoVend = 0;
Nombre = "";
TotalVenta = 0;
}
public Vendedor(int Num, string nom, double Monto)
{
NoVend = Num;
Nombre = nom;
TotalVenta = Monto;
}
public void AsignarNo_Vend(int Numero)
{
NoVend = Numero;
}
public int ObtenerNo_Vend()
{
return NoVend;
}
public int no_vend
{
get { return NoVend; }
set { NoVend = value; }
}
public void AsignarNombre(string Nom)
{
Nombre = Nom;
}
public string ObtenerNombre()
{
return Nombre;
}
public string nombre
{
get { return Nombre; }
set { Nombre = value; }
}
public void AsignarVentatotal(double total)
{
TotalVenta = total;
}
public double ObtenerVentatotal()
{
return TotalVenta;
}
public double totalventa
{
get { return TotalVenta; }
set { TotalVenta = value; }
}
}
}

8.3 consola

class Program
{

static void Main(string[] args)
{
int sigue;
Vendedor[] compañia = new Vendedor[25];
int Numero;
string name;
double total;

do
{

Console.Clear();
Console.Write("Numero Vendedor:");
Numero = int.Parse(Console.ReadLine());

Console.Write("Nombre Vendedor:");
name = Console.ReadLine();
Console.Write("Monto de Venta:");
total = double.Parse(Console.ReadLine());
Vendedor VX = new Vendedor(Numero, name, total);
compañia[Numero - 1] = VX;
Console.WriteLine("Presione 1 para continuar, 0 para terminar");
sigue = int.Parse(Console.ReadLine());

}
while (sigue == 1);
Console.WriteLine(" Numero de Vendedor Nombre Vendedor Total de Venta");
int I;
for (I = 0; I < 25; I++)
{
if (compañia[I] != null)
{
Console.Write(" {0} {1} {2}", compañia[I].no_vend, compañia[I].nombre, compañia[I].totalventa);
}
}
Console.ReadLine();

}
}
}

practica 8.3 consola

8.2 vis

practica 8.2 vis

public partial class Form1 : Form
{
int J;
double Venta;
Arreglo VentaAnual = new Arreglo(12);
public Form1()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
label4.Visible = true;
button2.Visible = true;
button3.Visible = true;
J = int.Parse(textBox1.Text);

Venta = double.Parse(textBox2.Text);
VentaAnual.AcumularDato(J - 1, Venta);
}

private void button3_Click(object sender, EventArgs e)
{
listBox1.Items.Add(" Informe nual de ventas");
listBox1.Items.Add("");
for (J = 0; J < 12; J++)
switch (J)
{
case 0: listBox1.Items.Add("Enero=" + VentaAnual.ObtenerDato(J));
break;
case 1: listBox1.Items.Add("Febrero=" + VentaAnual.ObtenerDato(J));
break;
case 2: listBox1.Items.Add("Marzo=" + VentaAnual.ObtenerDato(J));
break;
case 3: listBox1.Items.Add("Abril=" + VentaAnual.ObtenerDato(J));
break;
case 4: listBox1.Items.Add("Mayo=" + VentaAnual.ObtenerDato(J));
break;
case 5: listBox1.Items.Add("Junio=" + VentaAnual.ObtenerDato(J));
break;
case 6: listBox1.Items.Add("Julio=" + VentaAnual.ObtenerDato(J));
break;
case 7: listBox1.Items.Add("Agosto=" + VentaAnual.ObtenerDato(J));
break;
case 8: listBox1.Items.Add("Septiembre=" + VentaAnual.ObtenerDato(J));
break;
case 9: listBox1.Items.Add("Octubre=" + VentaAnual.ObtenerDato(J));
break;
case 10: listBox1.Items.Add("Noviembre=" + VentaAnual.ObtenerDato(J));
break;
case 11: listBox1.Items.Add("Diciembre=" + VentaAnual.ObtenerDato(J));
break;
}
textBox3.Text = VentaAnual.suma(12).ToString();


}

private void button2_Click(object sender, EventArgs e)
{
label4.Visible = false;
button2.Visible = false;
button3.Visible = false;
textBox1.Clear();
textBox2.Clear();
textBox1.Focus();
}


}
}



class Arreglo

{
double[] Elemento;
public Arreglo()
{
Elemento = new double[12];

}
public Arreglo(int N)
{
Elemento = new double[N];
}
public void introducirDato(int J, double X)
{
Elemento[J] = X;
}
public void AcumularDato(int J, double X)
{
Elemento[J] = Elemento[J] + X;
}
public double ObtenerDato(int J)
{
return Elemento[J];
}
public double [] elemento
{
get{return Elemento;}

set { Elemento=value;}
}
public double suma(int N)
{
int I;
double sum = 0.0;
for (I = 0; I < N; I++)
{
sum = sum + Elemento[I];
}
return sum;
}



}
}

8.2 consola

practica 8.2 consola

namespace practica8consola
{
class Program
{
static void Main(string[] args)
{
Arreglo VentaAnual = new Arreglo(12);
double Venta;
int J;
int Continuar;
do
{
Console.Write("Introduce numero y mes por ejemplo 1 Enero 2 Febrero 3 marzo etc.");
J = int.Parse(Console.ReadLine());
Console.Write(" Venta del Mes= ");
Venta = double.Parse(Console.ReadLine());
VentaAnual.AcumularDato(J - 1, Venta);
Console.Write(" Presione 1 para Continuar 0 para cerrar:");
Continuar = int.Parse(Console.ReadLine());
}
while (Continuar == 1);
Console.WriteLine(" Informe anual de ventas");
Console.WriteLine("");
for (J = 0; J < 12; J++)
switch (J)
{
case 0: Console.WriteLine("Enero={0}", VentaAnual.ObtenerDato(J));
break;
case 1: Console.WriteLine("Febrero={0}", VentaAnual.ObtenerDato(J));
break;
case 2: Console.WriteLine("Marzo={0}", VentaAnual.ObtenerDato(J));
break;
case 3: Console.WriteLine("Abril={0}", VentaAnual.ObtenerDato(J));
break;
case 4: Console.WriteLine("Mayo={0}", VentaAnual.ObtenerDato(J));
break;
case 5: Console.WriteLine("Junio={0}", VentaAnual.ObtenerDato(J));
break;
case 6: Console.WriteLine("Julio={0}", VentaAnual.ObtenerDato(J));
break;
case 7: Console.WriteLine("Agosto={0}", VentaAnual.ObtenerDato(J));
break;
case 8: Console.WriteLine("Septiembre={0}", VentaAnual.ObtenerDato(J));
break;
case 9: Console.WriteLine("Octubre={0}", VentaAnual.ObtenerDato(J));
break;
case 10: Console.WriteLine("Noviembre={0}", VentaAnual.ObtenerDato(J));
break;
case 11: Console.WriteLine("Diciembre={0}", VentaAnual.ObtenerDato(J));
break;


}
Console.WriteLine(" La venta anual es {0}", VentaAnual.suma(12));
Console.ReadLine();





}
}
}




class Arreglo
{
double[] Elemento;
public Arreglo()
{
Elemento = new double[12];

}
public Arreglo(int N)
{
Elemento = new double[N];
}
public void introducirDato(int J, double X)
{
Elemento[J] = X;
}
public void AcumularDato(int J, double X)
{
Elemento[J] = Elemento[J] + X;
}
public double ObtenerDato(int J)
{
return Elemento[J];
}
public double[] elemento
{
get { return Elemento; }

set { Elemento = value; }
}
public double suma(int N)
{
int I;
double sum = 0.0;
for (I = 0; I < N; I++)
{
sum = sum + Elemento[I];
}
return sum;
}



}
}

çractica 8.2 consola y visual

practica 8.1 clase

class Arreglo
{
double[] Elements;
public Arreglo()
{
Elements = new double[1000];
}
public Arreglo(int N)
{
Elements = new double[N];
}
public void AsignarDato(int J, double dato)
{
Elements[J] = dato;
}
public double ObtenerDato(int J)
{
return Elements[J];
}
public double[] elements
{
get { return Elements; }
set { Elements = value; }
}
public double SumaCuadrada(int N)
{
double Sum = 0;
int I;
for (I = 0; I < N; I++)
{
Sum = Sum + Math.Pow(Elements[I], 2);
}
return Sum;
}
public double SumaDatos(int N)
{
double Sum = 0;
int I;
for (I = 0; I < N; I++)
{
Sum = Sum + Elements[I];
}
return Sum;
}
}
}

practica 8.1

public partial class Form1 : Form
{
int I = 0;
Arreglo H = new Arreglo();
Arreglo F = new Arreglo();
public Form1()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{

textBox1.Enabled = false;
int Stu;
double Data1, Data2, R;
Stu = int.Parse(textBox1.Text);
textBox2.Focus();
if (I < Stu)
{
label2.Text = ("H" + (I + 2));
Data1 = double.Parse(textBox2.Text);
H.elements[I] = Data1;
label3.Text = ("F" + (I + 2));
Data2 = double.Parse(textBox3.Text);
F.elements[I] = Data2;
I++;
textBox2.Clear();
textBox3.Clear();
textBox1.Focus();
}

if (I == Stu)
{
label2.Text = ("H" + (Stu));
label3.Text = ("F" + (Stu));
textBox2.Clear();
textBox2.Enabled = false;
textBox3.Clear();
textBox3.Enabled = false;
double s = 0.0;
for (I = 0; I < Stu; I++)
{
s = s + H.ObtenerDato(I) * F.ObtenerDato(I);
}
double Numerator = Stu * s - H.SumaDatos(Stu) * F.SumaDatos(Stu);
double Denominator = Math.Sqrt((Stu * H.SumaCuadrada(Stu) - (Math.Pow(H.SumaDatos(Stu), 2))) * (Stu * F.SumaCuadrada(Stu) - (Math.Pow(F.SumaDatos(Stu), 2))));
R = Numerator / Denominator;
textBox4.Text = R.ToString();
}


}
}
}

practica8.1

resumen de archivos en C#

Archivos en C#
Un archivo o un fichero es una colección de información que almacenamos en un soporte magnético para poderla manipular en cualquier momento. Esta información se almacena como un conjunto de registros, los cuales contienen, generalmente, los mismos campos. Cada campo almacena un dato de un tipo predefinido o de un tipo definido por el usuario.
Un ejemplo seria, si quisiéramos almacenar en un fichero los datos relativos a la agenda de teléfonos, podríamos diseñar cada registro con los campos nombre, dirección y teléfono. Cada campo almacenara el dato correspondiente. El conjunto de campos descritos forma lo que hemos denominado registro, y el conjunto de todos los registros forma un archivo que almacenamos.
Entonces para manipular un archivo que identificamos por un nombre, son tres: abrir el fichero, escribir o leer registros del fichero y cerrar el fichero.
Podemos agrupar los archivos en dos tipos: de la aplicación y de datos, y además ofrece dos tipos diferentes de acceso a los archivos de datos: secuencial y aleatorio.
Para dar soporte a los archivos la biblioteca de C# proporciona varias clases de entrada y salida que permiten leer y escribir datos desde archivos y dispositivos.
Abriendo ficheros para acceso secuencial
El tipo de acceso simple a un archivo de datos es el secuencial, un archivo abierto para esta es un archivo que puede almacenar registros de cualquier longitud. Cuando la información se escribe registro a registro, estos son colocados de uno en uno y cuando se leen se empieza por el primero y se continúa hasta el último.
Este acceso utiliza dos archivos de texto en los que se escribe información desde el principio hasta el final y se lee igual que el secuencial. En cambio los archivos de texto no son los mas apropiados para almacenar grandes series de números porque cada numero es almacenado como una secuencia byte.
Flujo de bytes
Los datos puede ser escritos o leídos de un fichero byte a byte usando el FileStream: Este flujo permite leer y escribir bytes en un fichero. Esta clase aparte de los métodos heredados de la clase Stream proporciona los constructores siguientes:
FileStream(string nombre, FileMode modo)
FileStream(string nombre, FileMode modo, FileAccess acceso)
El primer constructor abre un flujo de entrada y salida vinculado con el fichero especificado por nombre, mientras el segundo hace lo mismo, pero con la posibilidad de especificar el tipo de acceso. El parámetro nombre es una cadena de caracteres que especifica la ruta donde esta guardando o se guardara el archivo. Esta cadena se escribe de dos maneras:
“c:\\temp\\doc.txt”
@“c:\temp\doc.txt” (la ventaja de usar @ y comillas es que las secuencias de escape no se procesan)
Flujo de caracteres
Los datos pueden ser escritos o leidos de un fichero carácter a carácter en un formato portable utilizando flujos de las clases StreamWriter y StreamReader, subclases de TextWriter y TextReader, respectivamente.
StreamWriter
Permite escribir caracteres en un fichero, además de los métodos heredados de la clase TextWriter, proporciona los constructores siguientes:
StreamWriter(string nombre)
StreamWriter(Stream flujo))
El primer constructor abre un flujo de salida hacia el fichero especificado por nombre, mientras que el segundo hace lo mismo, pero desde otro flujo existente de la clase Stream o de sus derivadas.
StreamReader
Permite leer caracteres desde un fichero. Esta clase, además de los métodos que hereda de la clase TextReader, proporciona los constructores siguientes:
StreamReader(string nombre)
StreamReader(Stream Flujo)
El primer constructor abre un flujo de entrada desde el fichero especificado por nombre, mientras que el segundo hace lo mismo, pero desde otro flujo existente de la clase Stream o de sus derivadas.
Clases File, Directory y Path
Estas soportan la manipulación del nombre de un fichero o de un directorio que puede existir en el sistema de ficheros de la mquina, sus métodos permitirán interrogar al sistema sobre las características de ese fichero o directorio. Todos los métodos son static para poder ser invocados sin necesidad de que exista un objeto de ellas.

Para referirnos a un fichero o directorio, lo mas sencillo es formar un string a partir de su nombre al que podremos añadir opcionalmente su ruta de acceso.
“c:\\MiDir\\MiFichero.txt”
@“c:\MiDir\MiFichero.txt”
@“c:\MiDir”
“MiDir\\MiSubDir\\MiFichero.txt”
@“MiDir\MiSubDir\MiFichero.txt”
@“MiDir\MiSubDir”
“MiFichero.txt”
“\\\\MiServidor\\MiDirCompartido\\MiFichero.txt”
Flujos de datos de tipos primitivos
Muchas aplicaciones requieren escribir en un fichero datos de tipos primitivos no como cadenas de caracteres sino formato binario para posteriormente recuperarlos. Para estos casos, el espacio de nombre System.IO proporciona las clases BinaryReader y BinaryWriter, las cuales permiten leer y escribir, respectivamente, datos de cualquier tipo primitivo en formato binario y cadenas de caracteres en formato UTF-8. Un flujo BinaryReader solo puede leer datos almacenados en un fichero a través de un flujo BinaryWriter.
BinaryWriter
Un flujo de la clase BinaryWriter permite a una aplicación escribir datos de cualquier tipo primitivo. Se puede crear un flujo de esta clase utilizando el siguiente constructor:
BinaryWriter(Stream Flujo)
Este constructor abre un flujo de salida (para escribir) hacia el fichero vinculado con otro flujo existente de la clase Stream o de sus derivadas.
BinaryReader
Un flujo de la clase BinaryReader permite a una aplicación escribir datos de cualquier tipo primitivo escritos por un flujo de la clase BinaryWriter. Se puede crear un flujo de esta clase utilizando el siguiente constructor:
BinaryReader(Stream Flujo)
Este constructor abre un flujo de salida (para leer) hacia el fichero vinculado con otro flujo existente de la clase Stream o de sus derivadas.

practica 7 visual

clase prac.7visual

class Arreglo
{
int[] Valores;
int I;

public Arreglo()
{
Valores = new int[10];
I = 0;
}
public Arreglo(int N)
{
Valores = new int[N];
I = 0;
}
public void AsignarDato(int J, int nuevoDato)
{
Valores[J] = nuevoDato;
}
public int ObtenerDato(int J)
{
return Valores[J];
}
public int Mayor(int N)
{
int May = Valores[0];
int Pos = 0;

for (I = 1; I < N; I++)
{
if (Valores[I] > May)
{
May = Valores[I];
Pos = I;
}
}
return Pos;
}
public int Menor(int N)
{
int Men = Valores[0];
int Pos = 0;

for (I = 1; I < N; I++)
{
if (Valores[I] < Men)
{
Men = Valores[I];
Pos = I;
}
}
return Pos;
}
public double Promedio(int N)
{
int I;
double Suma = 0.0;

for (I = 0; I < N; I++)
{
Suma = Suma + Valores[I];
}
return Suma / N;
}

public void LimpiarArreglo(int N)
{
int I;
for (I = 0; I < N; I++)
{
Valores[I] = 0;
}
}


}
}

practica 7 visual

public partial class Form1 : Form
{
int I = 0;
int Dato;

public Form1()
{
InitializeComponent();
}
Arreglo Emax = new Arreglo();

private void button4_Click(object sender, EventArgs e)
{
if (I >= 0 && I < 9)
{
Dato = int.Parse(textBox1.Text);
Emax.AsignarDato(I, Dato);
listBox1.Items.Add((I + 1) + ". " + Emax.ObtenerDato(I));
textBox1.Clear();
textBox1.Focus();
maskedTextBox1.Text = Convert.ToString(I + 2);
I++;
}
else
{
button4.Enabled = false;
}
}

private void button1_Click(object sender, EventArgs e)
{
Dato = int.Parse(textBox1.Text);
Emax.AsignarDato(I, Dato);
listBox1.Items.Add((I + 1) + ". " + Emax.ObtenerDato(I));
int PosMay = Emax.Mayor(10);
textBox2.Text = Convert.ToString(Emax.ObtenerDato(PosMay));
textBox3.Text = Convert.ToString(PosMay + 1);
int PosMen = Emax.Menor(10);
textBox4.Text = Convert.ToString(Emax.ObtenerDato(PosMen));
textBox5.Text = Convert.ToString(PosMen + 1);
textBox6.Text = Emax.Promedio(10).ToString();

}

private void Form1_Load(object sender, EventArgs e)
{
maskedTextBox1.Text = Convert.ToString(I + 1);
}

private void button2_Click(object sender, EventArgs e)
{
I = 0;
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox4.Clear();
textBox5.Clear();
textBox6.Clear();
listBox1.Items.Clear();
maskedTextBox1.Text = Convert.ToString(I + 1);
Emax.LimpiarArreglo(10);
listBox1.Items.Clear();
button4.Enabled = true;
}

private void button3_Click(object sender, EventArgs e)
{
Close();
}
}

}

practica 4.2 visual

namespace practica4._2
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
int OP;
double Total;
OP = int.Parse(textBox1.Text);
int Cantidad= int.Parse(textBox2.Text);
Total = 0.0;
switch (OP)
{
case 1:
Total = Total + (Cantidad * 29.8);
break;
case 2:
Total = Total + (Cantidad * 45.00);
break;
case 3:
Total = Total + (Cantidad * 99.8);
break;
case 4:
Total = Total + (Cantidad * 44.9);
break;
case 5:
Total = Total + (Cantidad * 68.75);
break;
}


textBox3.Text = Total.ToString();


}

private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
}

private void button3_Click(object sender, EventArgs e)
{
Close();
}


}
}

practica 4.2 visual

4.1 visual triangulo

namespace practica4._1form
{
public partial class TrianguloF : Form
{
public TrianguloF()
{
InitializeComponent();
}

private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
{

}

private void button1_Click(object sender, EventArgs e)
{
double Lado1, Lado2, Lado3, Area, Perimetro, SP;

Lado1 = double.Parse(textBox1.Text);
Lado2 = double.Parse(textBox2.Text);
Lado3 = double.Parse(textBox3.Text);
Perimetro = Lado1 + Lado2 + Lado3;
SP = Perimetro / 2;
Area = Math.Sqrt((SP - Lado1) * (SP - Lado2) * (SP - Lado3) * SP);


listBox1.Items.Add("El Area es: " + Area);
listBox1.Items.Add("");
listBox1.Items.Add("El Perimetro es: " + Perimetro);
}

private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
listBox1.Items.Clear();
}

private void button3_Click(object sender, EventArgs e)
{
Close();
}


}
}

4.1 visual rectangulo

namespace practica4._1form
{
public partial class RectanguloF : Form
{
public RectanguloF()
{
InitializeComponent();
}

private void label1_Click(object sender, EventArgs e)
{

}

private void button1_Click(object sender, EventArgs e)
{
double Ancho, Largo, Area, Perimetro;
Largo = double.Parse(textBox1.Text);
Ancho = double.Parse(textBox2.Text);
Area = Ancho * Largo;
Perimetro = (Ancho * 2) + (Largo * 2);

listBox1.Items.Add("El Area del rectangulo es:" + Area);
listBox1.Items.Add("");
listBox1.Items.Add("El Perimetro del rectangulo es:" + Perimetro);
}

private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
listBox1.Items.Clear();
}

private void button3_Click(object sender, EventArgs e)
{

Close();
}








}
}

4.1 visual Cuadrado

namespace practica4._1form
{
public partial class CuadradoF : Form
{
public CuadradoF()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
double Area, Perimetro;
double LADO = double.Parse(textBox1.Text);
Area = LADO * LADO;
Perimetro = LADO * 4;
listBox1.Items.Add("El Area del cuadrado es:" + Area);
listBox1.Items.Add("");
listBox1.Items.Add("El Perimetro del cuadrado es:" + Perimetro);
}

private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
listBox1.Items.Clear();
}

private void button3_Click(object sender, EventArgs e)
{
Close();
}










}
}

4.1 visual Circulo

namespace practica4._1form
{
public partial class CirculoF : Form
{
public CirculoF()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
double Radio, Area, Perimetro;
Radio = double.Parse(textBox1.Text);

Area = Math.PI * Radio * Radio;
Perimetro = 2 * Radio * Math.PI;

listBox1.Items.Add("El Area del Circulo es: " + Area);
listBox1.Items.Add("");
listBox1.Items.Add("El Perimetro del Circulo es: " + Perimetro);
}

private void button2_Click(object sender, EventArgs e)
{
listBox1.Items.Clear();
textBox1.Clear();
}

private void button3_Click(object sender, EventArgs e)
{
Close();
}



}
}

practica 4.1 visual.Form

namespace practica4._1form
{
public partial class Form1 : Form
{
CuadradoF jCuadrado;
RectanguloF jRectangulo;
CirculoF jCirculo;
TrianguloF jTriangulo;
public Form1()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
if ((jCuadrado == null) || (jCuadrado.IsDisposed))
{
jCuadrado = new CuadradoF();
}

jCuadrado.Show();
jCuadrado.BringToFront();

}

private void button2_Click(object sender, EventArgs e)
{
if ((jRectangulo == null) || (jRectangulo.IsDisposed))
{
jRectangulo = new RectanguloF();
}

jRectangulo.Show();
jRectangulo.BringToFront();
}

private void button3_Click(object sender, EventArgs e)
{
if ((jCirculo == null) || (jCirculo.IsDisposed))
{
jCirculo = new CirculoF();
}

jCirculo.Show();
jCirculo.BringToFront();
}

private void button4_Click(object sender, EventArgs e)
{
if ((jTriangulo == null) || (jTriangulo.IsDisposed))
{
jTriangulo = new TrianguloF();
}

jTriangulo.Show();
jTriangulo.BringToFront();
}
}
}

practica4.1 visual

practica 7 consola

namespace practica_7
{
class Program
{
static void Main(string[] args)
{
Arreglo emax = new Arreglo();
int I, dato;
Console.WriteLine("Introduce los siguientes datos");
for (I = 0; I <>
{
Console.WriteLine("dato {0}:", I + 1);
dato = int.Parse(Console.ReadLine());
emax.AsignarDato(I, dato);
}
Console.Clear();

Console.WriteLine("Lista de valores:");
for (I = 0; I <>
{
Console.Write("{0}", emax.obtenerDato(I));
}
Console.WriteLine();
int posMay = emax.May(10);
Console.WriteLine("El valor maximo es {0}", emax.obtenerDato(posMay));

Console.WriteLine("Este es el elemento numero {0} en la lista de los numeros", posMay + 1);
Console.ReadKey();

}
}
}

practica 7 consola

practica 4 prob 2 consola

practica 4 prob 2 consola

class Program
{
static void Main(string[] args)
{
int producto;
double total = 0.0;
char cont;
Console.WriteLine("Producto Precio");
Console.WriteLine(" 1 $ 29.80");
Console.WriteLine(" 2 $ 45.00");
Console.WriteLine(" 3 $ 99.80");
Console.WriteLine(" 4 $ 44.90");
Console.WriteLine(" 5 $ 68.75");

do
{
Console.WriteLine("Introduce el numero de producto:");
producto = int.Parse(Console.ReadLine());
Console.WriteLine("Introduce la cantidad de productos:");
int cantidad = int.Parse(Console.ReadLine());
switch (producto)
{
case 1:
total = total + cantidad * 29.8;
break;
case 2:
total = total + cantidad * 45.00;
break;
case 3:
total = total + cantidad * 99.8;
break;
case 4:
total = total + cantidad * 44.9;
break;
case 5:
total = total + cantidad * 68.75;
break;
}
Console.WriteLine("La venta total es: {0}", total);
Console.Write("siguiente s= si / n= no : ");
cont = char.Parse(Console.ReadLine());

}
while (cont == 's' || cont == 'S');

Console.ReadKey();


}
}
}

practica 4 consola

practica 4 consola

namespace practica_4
{
class Program
{
static void Main(string[] args)
{

{
int Clado, Base, h, A, B, C, Rad;
double Area = 0.0;
double Perimetro = 0.0;
double Sp;
char continuar;
do
{
Console.Clear();
Area = 0.0;
Perimetro = 0.0;

Console.WriteLine("AREA Y PERIMETRO");
Console.WriteLine("1. Cuadrado ");
Console.WriteLine("2. Rectángulo ");
Console.WriteLine("3. Triángulo ");
Console.WriteLine("4. Círculo ");
Console.Write("Que figura desea calcular: ");
int opcion = int.Parse(Console.ReadLine());
switch (opcion)
{
case 1: Console.Write("Introduce el valor del lado del cuadrado: ");
Clado = int.Parse(Console.ReadLine());
Area = Clado * Clado;
Perimetro = 4 * Clado;
Console.WriteLine("Área del Cuadrado={0} ", Area);
Console.WriteLine("Perímetro del Cuadrado={0} ", Perimetro);
break;

case 2: Console.Write("Introduce el valor de la base del Rectángulo: ");
Base = int.Parse(Console.ReadLine());
Console.Write("Introduce el valor de la altura del Rectángulo: ");
h = int.Parse(Console.ReadLine());
Area = Base * h;
Perimetro = (2 * Base) + (2 * h);
Console.WriteLine("Área del Rectángulo= {0} ", Area);
Console.WriteLine("Perímetro del Rectángulo= {0} ", Perimetro);
break;

case 3: Console.Write("Introduce el lado A del Triángulo: ");
A = int.Parse(Console.ReadLine());
Console.Write("Introduce el lado B del Triángulo: ");
B = int.Parse(Console.ReadLine());
Console.Write("Introduce el lado C del Triángulo: ");
C = int.Parse(Console.ReadLine());
Perimetro = A + B + C;
Sp = (Perimetro) / 2;
Console.WriteLine(" ");
Area = Math.Sqrt((Sp - A) * (Sp - B) * (Sp - C) * Sp);
Console.WriteLine("Área del Triángulo= {0}", Area);
Console.WriteLine("Perímetro del Triángulo= {0}", Perimetro);
break;

case 4: Console.Write("Introduce el Radio del Círculo: ");
Rad = int.Parse(Console.ReadLine());
Perimetro = Math.PI * (2 * Rad);
Area = Math.PI * (Rad * Rad);
Console.WriteLine("Área del Círculo= {0}", Area);
Console.WriteLine("Perímetro del Círculo= {0}", Perimetro);
break;

default:
Console.WriteLine("Error: tecla equivocada");
break;
}

Console.Write("Desea calcular otra figura s Si / n No : ");
continuar = char.Parse(Console.ReadLine());
}
while (continuar == 's');
Console.ReadKey();

}
}
}

}

practica 6

practica 6 consola

namespace practica6class
{
class Program
{
static void Main(string[] args)
{
Alumno A1 = new Alumno();
int Id;
string Name;
double Calf1, Calf2, Calf3, Calf4;
Console.Write("Introduce el numero de identificacion del alumno:");
Id = int.Parse(Console.ReadLine());
Console.Write("Introduce el nombre del alumno:");
Name= string.Format(Console.ReadLine());
Console.Write("Introduce la calificacion 1:");
Calf1 = double.Parse(Console.ReadLine());
Console.Write("Introduce la calificacion 2:");
Calf2 = double.Parse(Console.ReadLine());
Console.Write("Introduce la calificacion 3:");
Calf3 = double.Parse(Console.ReadLine());
Console.Write("Introduce la calificacion 4:");
Calf4 = double.Parse(Console.ReadLine());
A1.AsignarId(Id);
A1.AsignarNombre(Name);
A1.AsignarCalificacion1(Calf1);
A1.AsignarCalificacion2(Calf2);
A1.AsignarCalificacion3(Calf3);
A1.AsignarCalificacion4(Calf4);
Console.WriteLine("Promedio={0}", A1.Promedio());

Alumno A2 = new Alumno();

Console.Write("\nIntroduce el numero de identificacion del alumno:");
Id = int.Parse(Console.ReadLine());
Console.Write("Introduce el nombre del alumno:");
Name= string.Format(Console.ReadLine());
Console.Write("Introduce la calificacion 1:");
Calf1 = double.Parse(Console.ReadLine());
Console.Write("Introduce la calificacion 2:");
Calf2 = double.Parse(Console.ReadLine());
Console.Write("Introduce la calificacion 3:");
Calf3 = double.Parse(Console.ReadLine());
Console.Write("Introduce la calificacion 4:");
Calf4 = double.Parse(Console.ReadLine());
A2.AsignarId(Id);
A2.AsignarNombre(Name);
A2.AsignarCalificacion1(Calf1);
A2.AsignarCalificacion2(Calf2);
A2.AsignarCalificacion3(Calf3);
A2.AsignarCalificacion4(Calf4);
Console.WriteLine("Promedio={0}", A2.Promedio());

Alumno A3 = new Alumno();

Console.Write("\nIntroduce el numero de identificacion del alumno:");
Id = int.Parse(Console.ReadLine());
Console.Write("Introduce el nombre del alumno:");
Name= string.Format(Console.ReadLine());
Console.Write("Introduce la calificacion 1:");
Calf1 = double.Parse(Console.ReadLine());
Console.Write("Introduce la calificacion 2:");
Calf2 = double.Parse(Console.ReadLine());
Console.Write("Introduce la calificacion 3:");
Calf3 = double.Parse(Console.ReadLine());
Console.Write("Introduce la calificacion 4:");
Calf4 = double.Parse(Console.ReadLine());
A3.AsignarId(Id);
A3.AsignarNombre(Name);
A3.AsignarCalificacion1(Calf1);
A3.AsignarCalificacion2(Calf2);
A3.AsignarCalificacion3(Calf3);
A3.AsignarCalificacion4(Calf4);
Console.WriteLine("Promedio={0}", A3.Promedio());
Console.ReadKey();
}
}
}

practica 6 clase

namespace practica6class
{
class Alumno
{
int Id;
string Nombre;
double Calf1, Calf2, Calf3, Calf4;
public Alumno()
{
Id = 0;
Calf1 = Calf2 = Calf3 = Calf4 = 0.0;
Nombre = "";
}
public void AsignarId(int nc)
{
Id = nc;
}
public void AsignarNombre(string Name)
{
Nombre = Name;
}
public void AsignarCalificacion1(double C1)
{
Calf1 = C1;
}
public void AsignarCalificacion2(double C2)
{
Calf2 = C2;
}
public void AsignarCalificacion3(double C3)
{
Calf3 = C3;
}
public void AsignarCalificacion4(double C4)
{
Calf4 = C4;
}
public double Promedio()
{
double suma = (Calf1 + Calf2 + Calf3 + Calf4) / 4;
return suma;
}
}
}

class rectangulo

using System;
using System.Collections.Generic;
using System.Text;

namespace figuras
{
class Rectangulo
{
double ancho;
double largo;
public Rectangulo()
{
ancho = 0;
largo = 0;
}
public Rectangulo(double w, double h)
{
ancho = w;
largo = h;
}
public double Area()
{
return ancho * largo;
}
public double Perimetro()
{
return 2 * (ancho + largo);
}
public void Asignarlargo(double h)
{
largo = h;
}
public void Asignarancho(double w)
{
ancho = w;
}
public double obtenerlargo()
{
return largo;
}
public double obtenerancho()
{
return ancho;
}
}
}

class circulo

using System;
using System.Collections.Generic;
using System.Text;

namespace figuras
{
class Circulo
{
double radio;
public Circulo()
{
radio = 0;
}
public Circulo(double R)
{
radio = R;
}
public void Asignarradio(double rad)
{
radio = rad;
}
public double obtenerradio()
{
return radio;
}
public double Area()
{
double A = Math.PI * Math.Pow(radio, 2);
return A;
}
public double circunferencia()
{
double P = 2 * Math.PI * radio;
return P;
}

}
}

class triangulo

using System;
using System.Collections.Generic;
using System.Text;

namespace figuras
{
class Triangulo
{
double Lado1;
double Lado2;
double Lado3;
public Triangulo()
{
Lado1 = 0;
Lado2 = 0;
Lado3 = 0;
}
public Triangulo(double L1, double L2, double L3)
{
Lado1 = L1;
Lado2 = L2;
Lado3 = L3;
}
public double Area()
{
return Math.Sqrt((Lado1 + Lado2 + Lado3) / 2 * ((Lado1 + Lado2 + Lado3) / 2 - Lado1) * ((Lado1 + Lado2 + Lado3) / 2 - Lado2) * ((Lado1 + Lado2 + Lado3) / 2 - Lado3));
}
public double Perimetro()
{
return (Lado1 + Lado2 + Lado3);
}
public void AsignarLado1(double L1)
{
Lado1 = L1;
}
public void AsignarLado2(double L2)
{
Lado2 = L2;
}
public void AsignarLado3(double L3)
{
Lado3 = L3;
}
public double obtenerLado1()
{
return Lado1;
}
public double obtenerLado2()
{
return Lado2;
}
public double obtenerLado3()
{
return Lado3;
}


}
}

figuras

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace figuras
{
class Program
{
static void Main(string[] args)
{
Rectangulo R1 = new Rectangulo();
double l, a;
Console.Write("Introduce largo de un rectangulo:");
l = double.Parse(Console.ReadLine());
Console.Write("Introduce ancho de un rectangulo:");
a = double.Parse(Console.ReadLine());
R1.Asignarlargo(l);
R1.Asignarancho(a);
Console.WriteLine("area ={0}", R1.Area());
Console.WriteLine("Perimetro={0}", R1.Perimetro());

Circulo C1 = new Circulo();
double r;
Console.Write("\nIntroduce radio circulo:");
r = double.Parse(Console.ReadLine());
C1.Asignarradio(r);
Console.WriteLine("Area Circulo :{0}", C1.Area());
Console.WriteLine("Perimetro Circulo : {0}", C1.circunferencia());

Triangulo T1 = new Triangulo();
double L1, L2, L3;
Console.Write("\nIntroduce Lado 1 del triangulo:");
L1 = double.Parse(Console.ReadLine());
Console.Write("Introduce Lado 2 del triangulo:");
L2 = double.Parse(Console.ReadLine());
Console.Write("Introduce Lado 3 del triangulo:");
L3 = double.Parse(Console.ReadLine());
T1.AsignarLado1(L1);
T1.AsignarLado2(L2);
T1.AsignarLado3(L3);
Console.WriteLine("Area ={0}", T1.Area());
Console.WriteLine("Perimetro={0}", T1.Perimetro());
Console.ReadKey();
}
}
}

practica5.prob2 consola

int t;
double termino;
Console.WriteLine("Introduce cantidad de terminos");
int n = int.Parse(Console.ReadLine());
Console.WriteLine("Introduce el primer termino:");
double a = double.Parse(Console.ReadLine());
Console.WriteLine("Introduce proporcion comun:");
double r = double.Parse(Console.ReadLine());
double suma=0.0;
for (t = 0; t <= n-1; t = t + 1)
{
termino = a * Math.Pow(r, t);
Console.Write(termino);
suma = suma + termino;
if (t == n - 1)
Console.Write(" = ");
else
Console.Write(" + ");

} Console.WriteLine(suma);
Console.ReadKey();

practica5 prob.1 visual

namespace prac._5prob1.vis
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void Form1_Load(object sender, EventArgs e)
{double dt = 0.0, g = 32.0, d, t;
for (t = 0; t <= 10; t = t + 1)
{
d = .5 * g * t * t;
dt = dt + d;
listBox1.Items.Add(t);
listBox2.Items.Add(d);
listBox3.Items.Add(dt);
}
}
}
}

practica 3 problema 2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace practica3prob2
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Numero de producto Precio de lista");
Console.WriteLine("1 $29.80");
Console.WriteLine("2 $45.00");
Console.WriteLine("3 $99.8");
Console.WriteLine("4 $44.90");
Console.WriteLine("5 $68.75");
Console.WriteLine("");

double total = 0.0;


Console.WriteLine("continuar ?");
Console.WriteLine("1. si");
Console.WriteLine("2. no");
char continuar = char.Parse(Console.ReadLine());
do
{

Console.Clear();
Console.WriteLine("Elige una opcion del 1 al 5");
int opcion = int.Parse(Console.ReadLine());
switch (opcion)
{
case 1: Console.WriteLine("Cantidad vendida durante el dia:");
double P1 = double.Parse(Console.ReadLine());
total = total + (P1 * 29.80);
Console.WriteLine("El total es:{0}", total);
Console.ReadLine();
break;
case 2: Console.WriteLine("Cantidad vendida durante el dia:");
double P2 = double.Parse(Console.ReadLine());
total = total + (P2 * 45.00);
Console.WriteLine("El total vendido es:{0}", total);
Console.ReadLine();
break;
case 3: Console.WriteLine("Cantidad vendida durante el dia:");
double P3 = double.Parse(Console.ReadLine());
total = total + (P3 * 99.8);
Console.WriteLine("El total vendido es:{0}", total);
Console.ReadLine();
break;
case 4: Console.WriteLine("Cantidad vendida durante el dia:");
double P4 = double.Parse(Console.ReadLine());
total = total + (P4 * 44.90);
Console.WriteLine("El total vendido es:{0}", total);
Console.ReadLine();
break;
case 5: Console.WriteLine("Cantidad vendida durante el dia:");
double P5 = double.Parse(Console.ReadLine());
total = total + (P5 * 68.75);
Console.WriteLine("El total vendido es:{0}", total);
Console.ReadLine();
break;
default: Console.WriteLine("Presiona opcion equivocada");
break;
}



}

while (continuar == '1' );

Console.ReadLine();
}
}
}