Etiqueta: Microsoft

public void Sort(IComparable[] items){
   for(i=0; i<items.length; i++)
   {
      Icomparable tmp = items[i];
      items[i] = items[j];
      items[j] = tmp;
   }
}

//Definimos la clase persona
public class Persona: IComparable
{
   //Aqui usamos propiedades autoimplementadas (a partir de C# 3.0)
   //Fijate que no hay que definir primero las variables privadas
   public string Name { get; set; }
 
   public Date Birthday { get; set; }
 
   public float Height { get; set; }
 
   public Persona(string Name, Date Birthday, float Height)
   {
      this.Name = Name;
      this.Birthday = Birthday;
      this.Height = Height;
   }
 
   //Metodo CompareTo de la interfaz IComparable
   public int CompareTo(object obj)
   {
      Persona p = obj as Persona;
      //Comparamos las personas por Fecha de Nacimiento
      return this.Birthday.CompareTo(p.Birthday);
   }
}
//Clase Date que utilizamos en el campo Birthday de la clase Persona
public class Date : IComparable
{
   //Aqui usamos variables porque las propiedades Day, Month y Year
   //no tienen parte set
   int day, month, year;
 
   //Constructor de la clase
   public Date(int day, int month, int year)
   {
      this.day = day;
      this.month = month;
      this.year = year;
      if (!IsValid) throw new ArgumentException("Fecha no válida");
   }
 
   //Metodo para verificar si una fecha es valida
   bool IsValid
   {
      get{
         //Verifico si la fecha tiene rango valido
         if (year <= 0 || month <= 0 || month > 12 || day <= 0 || day > 31)
            return false;
         //Verifico si el año es bisiesto que febrero no tenga mas de 28 dias
         if ((year % 400 == 0 && month == 2 && day > 28) || (month == 2 && day > 29))
            return false;
         // Verifico los meses que no tienen 31 dias
         if ((month == 4 || month == 6 || month == 9 || month == 11) && day == 31)
            return false;
         return true;
      }
   }
 
   public int Day
   {
      get { return day; }
   }
   public int Month
   {
      get { return month; }
   }
   public int Year
   {
      get { return year; }
   }
 
   //Metodo para comparar fecha, nota que esta clase tambien hereda
   //de IComparable
   public int CompareTo(object x)
   {
      Date d = x as Date;
      if (d == null)
      throw new ArgumentException();
      // Uso operadores ternarios para comparar las fechas (asi me evito unos cuantos if else)
      return (d.Year > year || (d.Year == year && d.Month > month) || (d.Year == year && d.Month == month && d.Day > day)) ? -1 : (d.Year == year && d.Month == month && d.Day == day) ? 0 : 1;
   }
}
 
class Program
{
   //En el metodo Main es donde usamos las clases y
   //programamos algunos metodos que vayamos a utilizar
 
   static void Main(string[] args)
   {
      //Creo el array de personas que voy a ordenar
      Persona[] personas = new Persona[]
      {
         new Persona("Tom", new Date(1, 11, 1988), 169),
         new Persona("Jio", new Date(31, 8, 1990), 170),
         new Persona("Simone", new Date(7, 9, 1991), 165),
         new Persona("Ruben", new Date(22, 10, 1988), 165)
      };
 
      //Ordeno el array de personas
      Sort(personas);
 
      //Imprimo las personas despues de ordenarlas
      foreach (Persona p in personas)
      {
         Console.WriteLine("Nombre: {0}   Date: {1}, {2}, {3}, Height: {4}",
         p.Name, p.Birthday.Day, p.Birthday.Month, p.Birthday.Year, p.Height);
      }
      Console.ReadKey();
   }
 
   //Metodo de ordenacion sencillo
   //Puedes ver otros métodos de ordenación en post anteriores:
 
   static void Sort(IComparable[] items)
   {
      for (int i = 0; i < items.Length - 1; i++)
         for (int j = i + 1; j < items.Length; j++)
         //Comparamos las personas usando el metodo CompareTo que implementamos     
         if (items[i].CompareTo(items[j]) > 0){
            IComparable tmp = items[i];
            items[i] = items[j];
            items[j] = tmp;
         }
   }
}

public delegate [valor de retorno] Comparison([parametro 1], [parametro 2], ... , [parametro n]);

public delegate int Comparison(object x, object y);

static void Sort(Persona[] items, Comparison compare)
{
   for (int i = 0; i < items.Length - 1; i++)
      for (int j = i + 1; j < items.Length; j++)   
      //Comparamos usando el delegado    
      if (compare(items[i],items[j]) > 0)
      {
         Persona tmp = items[i];
         items[i] = items[j];
         items[j] = tmp;
      }
}

//Comparamos por nombre en orden alfabético
public static int CompareByName(object x, object y)
{
   Persona p1 = x as Persona;
   Persona p2 = y as Persona;
   //En C# se considera que una letra minuscula es menor que cualquier letra mayuscula
   //por eso tenemos que usar la propidad OrdinalIgnoreCase de la clase StringComparer
   return StringComparer.OrdinalIgnoreCase.Compare(p1.Name, p2.Name);
}
 
//Comparamos por altura de menor a mayor
public static int CompareByHeight(object x, object y)
{
   Persona p1 = x as Persona;
   Persona p2 = y as Persona;
   //El tipo float tiene un comparador por defecto, que es el que utilizamos
   return p1.Height.CompareTo(p2.Height);
}
 
//Comparamos por fecha de nacimiento como hacíamos en CompareTo
public static int CompareByBirthday(object x, object y)
{
   Persona p1 = x as Persona;
   Persona p2 = y as Persona;
   //El tipo float tiene un comparador por defecto, que es el que utilizamos
   return p1.Birthday.CompareTo(p2.Birthday);
}

static void Main(string[] args)
{
   Persona[] personas = new Persona[]
   {
      new Persona("Tom", new Date(1, 11, 1988), 169),
      new Persona("Jio", new Date(31, 8, 1990), 170),
      new Persona("Simone", new Date(7, 9, 1991), 165),
      new Persona("Ruben", new Date(22, 10, 1988), 165)
   };
 
   //Pasamos como parámetro al delegado el método CompareByName
   Sort(personas, Persona.CompareByName);
   //También se puede usar el nombre del método directamente sin pasarlo como parámetro
   //Sort(personas, new Comparison(Persona.CompareByName));
 
   Console.WriteLine("Ordenando las personas en orden alfabético");
   foreach (Persona p in personas)
   {
      Console.WriteLine("Nombre: {0}", p.Name);
   }
 
   Console.WriteLine();
   Console.WriteLine("Ordenando las personas por fecha de nacimiento");
   //Pasamos como parámetro al delegado el método CompareByBirthday
   Sort(personas, Persona.CompareByBirthday);
   foreach (Persona p in personas)
   {
      Console.WriteLine("Date: {0}, {1}, {2}",p.Birthday.Day, p.Birthday.Month, p.Birthday.Year);
   }
 
   Console.WriteLine();
   Console.WriteLine("Ordenando las personas por altura");
   //Pasamos como parámetro al delegado el método CompareByHeight
   Sort(personas, Persona.CompareByHeight);
   foreach (Persona p in personas)
   {
      Console.WriteLine("Height: {0}",p.Height);
   }
   Console.ReadKey();
}

//Comparamos por nombre en orden alfabético a partir d la segunda letra
public static int CompareFromSecondLetter(object x, object y)
{
   Persona p1 = x as Persona;
   Persona p2 = y as Persona;
   //Usamos substring para comparar los nombres a partir de la segunda letra
   return StringComparer.OrdinalIgnoreCase.Compare(p1.Name.Substring(1), p2.Name.Substring(1));
}

Sort(personas, Persona.CompareFromSecondLetter);