/// <summary> /// Agrega una nueva jornada con la clase ingresada /// </summary> /// <param name="g">Universidad donde se agrega la clase</param> /// <param name="clase">Clase a agregar </param> /// <returns> Retorna universidad con la clase y los alumnos de la clase</returns> public static Universidad operator +(Universidad g, EClases clase) { Jornada nuevaJornada = new Jornada(clase, g == clase); foreach (Alumno alumnoAux in g.alumnos) { if (alumnoAux == clase) { nuevaJornada.Alumnos.Add(alumnoAux); } } g.jornada.Add(nuevaJornada); return(g); }
/// <summary> /// Guarda los datos en el archivo txt, sino lanza un error controlado /// </summary> /// <param name="jornada"></param> /// <returns></returns> public static bool Guardar(Jornada jornada) { Texto texto = new Texto(); string fileName = Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "\\jornada.txt"; try { texto.Guardar(fileName, jornada.ToString()); return(true); } catch (Exception e) { throw new ArchivosException("Error al guardar Jornada.txt", e); } }
/// <summary> /// Asigna una clase a la universidads /// </summary> /// <param name="u"></param> /// <param name="clase"></param> /// <returns></returns> public static Universidad operator +(Universidad u, EClases clase) { Profesor profeAsignado = (u == clase); Jornada nuevaJornada = new Jornada(clase, profeAsignado); foreach (Alumno a in u.Alumnos) { if (a == clase) { nuevaJornada = nuevaJornada + a; } } u.jornadas.Add(nuevaJornada); return(u); }
/// <summary> /// Si un alumno toma la clase recibida por parámetro, se agrega el alumno a una jornada /// </summary> /// <param name="g">Universidad</param> /// <param name="clase">Clase</param> /// <returns></returns> public static Universidad operator +(Universidad g, EClases clase) { Jornada jor = new Jornada(clase, g == clase); g.jornada.Add(jor); foreach (Alumno alumno in g.alumnos) { if (alumno == clase) { jor += alumno; } } return g; }
/// <summary> /// Agregar una clase a una universidad, creara una nueva jornada con los instructores y alumnos que esten en esa clase. /// Caso contrario, se lanzaran las excepciones correspondientes. /// </summary> /// <param name="g"></param> /// <param name="clase"></param> /// <returns></returns> public static Universidad operator +(Universidad g, EClases clase) { Profesor unProfesor = (g == clase); Jornada nuevaJornada = new Jornada(clase, unProfesor); foreach (Alumno item in g.alumnos) { if (item == clase) { nuevaJornada.Alumnos.Add(item); } } g.Jornadas.Add(nuevaJornada); return(g); }
/// <summary> /// genera y agrega una nueva Jornada indicando la clase, un Profesor que pueda darla y la lista de alumnos que la toman. /// </summary> /// <param name="g"></param> /// <param name="clase"></param> /// <returns>El objeto de tipo Universidad con la Jornada cargada</returns> public static Universidad operator +(Universidad g, EClases clase) { Jornada auxJornada = new Jornada(clase, (g == clase)); foreach (Alumno item in g.alumnos) { if (item == clase) { auxJornada += item; } } g.jornada.Add(auxJornada); return(g); }
/// <summary> /// Al agregar una clase a un Universidad se deberá generar y agregar una nueva Jornada /// indicando la lase, un Profesor que pueda darla(según su atributo ClasesDelDia) /// y la lista de alumnos que la toman(todos los que coincidan en su campo ClaseQueToma). /// </summary> /// <param name="g"></param> /// <param name="clase"></param> /// <returns></returns> public static Universidad operator +(Universidad g, EClases clase) { Jornada jornadaAux = new Jornada(clase, g == clase); foreach (Alumno item in g.alumnos) { if (item == clase) { jornadaAux += item; } } g.jornada.Add(jornadaAux); return(g); }
public static Universidad operator +(Universidad uni, EClases clases) { Jornada jornadaNueva = new Jornada(clases, (uni == clases)); foreach (Alumno a in uni.alumnos) { if (a == clases) { jornadaNueva.Alumnos.Add(a); } } uni.jordanas.Add(jornadaNueva); return(uni); }
/// <summary> /// Agrega una nueva Clase, generando una nueva Jornada /// (con su respectivo Profesor y Alumnos que tomen esa clase) /// </summary> /// <param name="g">Universidad a cargar</param> /// <param name="clase">Clase deseada</param> /// <returns></returns> public static Universidad operator +(Universidad g, EClases clase) { Jornada jornada; Profesor profesor = g == clase; jornada = new Jornada(clase, profesor); foreach (Alumno aux in g.Alumnos) { if (aux == clase) { jornada = jornada + aux; } } g.Jornadas.Add(jornada); return(g); }
/// <summary> /// Agrega una nueva jornada de clase. Asigna un profesor a la misma /// y a los alumnos que tomen esa clase. /// </summary> /// <param name="g"></param>Universidad a la cual se le agregara una clase /// <param name="clase"></param>Clase a ser agregada /// <returns></returns>La universidad con la nueva jornada de clase cargada public static Universidad operator +(Universidad u, EClase clase) { Jornada jornadaAux = new Jornada(clase, u == clase); foreach (Alumno a in u.Alumnos) { if (a == clase) { jornadaAux.Alumnos.Add(a); } } u.Jornadas.Add(jornadaAux); return(u); }
public static Universidad operator +(Universidad g, EClases clase) { if (!object.ReferenceEquals(g, null)) { Jornada j = new Jornada(clase, g == clase); foreach (Alumno alumno in g.Alumnos) { if (!object.ReferenceEquals(alumno, null) && alumno == clase) // acá evaluo los alumnos que toman esa clase para agregarlos (en caso afirmativo) a la jornada { j += alumno; } } g.Jornadas.Add(j); } return(g); }
public static Universidad operator +(Universidad g, EClases clase) { Jornada jornada = new Jornada(clase, (g == clase)); foreach (Alumno alumno in g.Alumnos) { if (alumno == clase) { jornada += alumno; } } g.Jornadas.Add(jornada); return(g); }
public static bool Leer(Jornada jornada) { try { Texto t = new Archivos.Texto(); string datos; string archivo = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory) + "\\Jornada.txt"; bool s = t.Leer(archivo, out datos);; Console.WriteLine(datos); return(s); } catch (Exception e) { throw new ArchivosException(e); } }
public static Universidad operator +(Universidad u, EClases clase) { Jornada nuevaJornada = new Jornada(clase, u == clase); foreach (Alumno item in u.alumnos) { if (item == clase) { nuevaJornada.Alumnos.Add(item); } } u.jornada.Add(nuevaJornada); return(u); }
public static Universidad operator +(Universidad g, EClases clase) { Jornada auxJornada = new Jornada(clase, g == clase); foreach (Alumno alumno in g.alumnos) { if (alumno == clase) { auxJornada.Alumnos.Add(alumno); } } g.jornada.Add(auxJornada); return(g); }
/// <summary> /// Al agregar una clase a un Universidad se deberá generar y agregar una nueva Jornada indicando la ///clase, un Profesor que pueda darla(según su atributo ClasesDelDia) y la lista de alumnos que la ///toman(todos los que coincidan en su campo ClaseQueToma). /// </summary> /// <param name="uni"></param> /// <param name="clase"></param> /// <returns></returns> public static Universidad operator +(Universidad uni, EClases clase) { Profesor miProfesor; miProfesor = uni == clase; Jornada miJornada = new Jornada(clase, miProfesor); foreach (Alumno miAlumno in uni.Alumnos) { if (miAlumno == clase) { miJornada.Alumnos.Add(miAlumno); } } uni.Jornadas.Add(miJornada); return(uni); }
/// <summary> /// Guarda en un archivo de texto los datos de la jornada /// </summary> /// <param name="jornada"></param> /// <returns></returns> public static bool Guardar(Jornada jornada) { string ruta = AppDomain.CurrentDomain.BaseDirectory + "\\Jornada.txt"; Texto text = new Texto(); if (text.Guardar(ruta, jornada.ToString())) { return(true); } else { return(false); } }
public static bool Guardar(Jornada jornada) { Texto guardar = new Texto(); string archivo = AppDomain.CurrentDomain.BaseDirectory + "texto.txt"; bool rtnVal; try { rtnVal = guardar.Guardar(archivo, jornada.ToString()); } catch (Excepciones.ArchivosException) { rtnVal = false; } return(rtnVal); }
/// <summary> /// Guardar de clase guardará los datos de la Jornada en un archivo de texto. /// </summary> /// <param name="jornada"></param> /// <returns></returns> public static bool Guardar(Jornada jornada) { bool retorno = false; Texto texto = new Texto(); try { texto.Guardar("Jornada.txt", jornada.ToString()); retorno = true; } catch (ArchivosException e) { throw new ArchivosException(e); } return(retorno); }
/// <summary> /// Agregar una Clase a la Universidad, creando una nuva Jornada /// </summary> /// <param name="u">Universidad</param> /// <param name="clase">Clase</param> /// <returns>Devuelvo la universidad modificada</returns> public static Universidad operator +(Universidad u, Universidad.EClases clase) { Profesor profesor = (u == clase); Jornada jornada = new Jornada(clase, profesor); foreach (Alumno item in u.Alumnos) { if (item == clase) { jornada = jornada + item; } } u.Jornadas.Add(jornada); return(u); }
/// <summary> /// Al agregar una clase a un Universidad se deberá generar y agregar una nueva Jornada indicando la clase, /// un Profesor que pueda darla (según su atributo ClasesDelDia) /// y la lista de alumnos que la toman (todos los que coincidan en su campo ClaseQueToma). /// </summary> /// <param name="g"></param> /// <param name="clases"></param> /// <returns></returns> public static Universidad operator +(Universidad g, EClases clases) { Profesor profesorAsignado = (g == clases); Jornada nuevaJornada = new Jornada(clases, profesorAsignado); foreach (Alumno aux in g.Alumnos) { if (aux == clases) { nuevaJornada = nuevaJornada + aux; } } g.Jornadas.Add(nuevaJornada); return(g); }
/// <summary> /// Se encarga de generar una jornada y a su vez, determinar que profesor la da y /// que alumonos la toman /// </summary> /// <param name="g"></param> /// <param name="clase"></param> /// <returns></returns> public static Universidad operator +(Universidad g, EClases clase) { Jornada nuevaJornada = new Jornada(clase, g == clase); for (int i = 0; i < g.alumnos.Count; i++) { if (g.alumnos[i] == clase) { nuevaJornada += g.alumnos[i]; } } g.jornada.Add(nuevaJornada); return(g); }
/// <summary> /// Crea una jornada en la universidad de la clase indicada, con un profesor y los alumnos que tomen esa clase. /// </summary> /// <param name="u">la universidad</param> /// <param name="clase">la clase a dictar</param> /// <returns>la misma universidad con la jornada ya añadida</returns> public static Universidad operator +(Universidad u, EClases clase) { Profesor profesor = u == clase; Jornada jornada = new Jornada(clase, profesor); foreach (Alumno alumno in u.alumnos) { if (alumno == clase) { jornada += alumno; } } u.jornadas.Add(jornada); return(u); }
public static bool Guardar(Jornada jornada) { if (!(jornada is null)) { Texto texto = new Texto(); try { texto.Guardar("Jornada.txt", jornada.ToString()); } catch (Exception e) { throw new ArchivosException(e); } } return(true); }
/// <summary> /// Guarda todos los datos de la jornada en un archivo txt,siempre y cuando cumpla con la condicion /// </summary> /// <param name="j"></param> /// <returns></returns> public static bool Guardar(Jornada j) { Texto textoJornada = new Texto(); try { if (textoJornada.Guardar(string.Format(AppDomain.CurrentDomain.BaseDirectory + "Jornada.txt"), j.ToString())) { return(true); } } catch (ArchivosException e) { throw new ArchivosException(e); } return(false); }
public static Universidad operator +(Universidad g, EClases clases) { Profesor profesor = g == clases; Jornada jornada = new Jornada(clases, profesor); foreach (Alumno a in g.alumnos) { if (jornada == a) { jornada += a; } } if (!object.Equals(jornada.Instructor, null)) { g.jornada.Add(jornada); } return(g); }
/// <summary> /// Agrega a la universidad una nueva jornada con la clase pasada como parametro, un profesor que pueda la dicha clase y la lista de alumnos que la toman /// </summary> /// <param name="g">La universidad.</param> /// <param name="clase">La clase</param> /// <returns>Devuelve la universidad pasada como parametro</returns> public static Universidad operator +(Universidad g, EClases clase) { Jornada nuevaJornada = new Jornada(clase, g == clase); foreach (Alumno alumno in g.Alumnos) { if (alumno == clase) { nuevaJornada.Alumnos.Add(alumno); } } if (nuevaJornada.Alumnos.Count > 0) { g.Jornadas.Add(nuevaJornada); } return(g); }
/// <summary> /// Sobreescritura del operator +, recibe una universidad y una clase, crea una jornada para la clase y le asigna un profesor /// y la agrega a la universidad /// </summary> /// <param name="uni"></param> /// <param name="clase"></param> /// <returns>retorna la universidad con la jornada agregada en caso de que halla profesor, sino retorna la misma universidad</returns> public static Universidad operator +(Universidad uni, EClases clase) { Profesor auxProfe = (uni == clase); if (auxProfe != null) { Jornada auxJor = new Jornada(clase, auxProfe); foreach (Alumno a in uni.Alumnos) { if (a == clase) { auxJor += a; } } uni.jornada.Add(auxJor); } return(uni); }
/// <summary> /// Operador que agrega una clase a la universidad con un profesor que la dicte /// </summary> /// <param name="g"></param> /// <param name="clase"></param> /// <returns></returns> public static Universidad operator +(Universidad g, EClases clase) { Profesor p = (g == clase); if (!Equals(p, null)) { Jornada j = new Jornada(clase, p); foreach (Alumno a in g.Alumnos) { if (a == clase) { j += a; } } g.jornada.Add(j); } return(g); }
public static Universidad operator +(Universidad uni, EClases clase) { Profesor p = uni == clase; if (p == clase) { Jornada j = new Jornada(clase, p); foreach (Alumno a in uni.Alumnos) { if (j == a) { j += a; } } uni.Jornadas.Add(j); } return(uni); }