El siguiente código implementa el algoritmo de ordenamiento por selección en una aplicación de consola.
namespace OrdenacionXSeleccion
{
#region [Bibliotecas de clases]
using System;
using System.Linq;
#endregion
/// <summary>
/// Clase que encapsula la lógica del algoritmo de ordenamiento por selección.
/// </summary>
public class Program
{
/// <summary>
/// Método de ejecución principal.
/// </summary>
/// <param name="args">Argumentos.</param>
public static void Main(string[] args)
{
Console.WriteLine("Ingresa los numeros a ordenar separados por comas(,) y presiona la tecla Enter.");
int[] vector = Console.ReadLine().Replace(" ", "").Split(',').Select(x => Convert.ToInt32(x)).ToArray();
Console.WriteLine();
Console.WriteLine("Vector ordenado:");
Console.WriteLine(string.Join(",", Ordenar(vector)));
Console.WriteLine();
Console.WriteLine("Presiona una tecla para salir.");
Console.ReadKey();
}
/// <summary>
/// Método que implementa el algoritmo de ordenación por selección a un vector´.
/// </summary>
/// <param name="vector">Vector que contiene los elementos a ordenar.</param>
/// <returns>Vector ordenado.</returns>
private static int[] Ordenar(int[] vector)
{
int menor, posicion, auxiliar;
for (int i = 0; i < vector.Length - 1; i++)
{
menor = vector[i];
posicion = i;
for (int j = i + 1; j < vector.Length; j++)
{
if (vector[j] < menor)
{
menor = vector[j];
posicion = j;
}
}
if (posicion != i)
{
auxiliar = vector[i];
vector[i] = vector[posicion];
vector[posicion] = auxiliar;
}
}
return vector;
}
}
}
El siguiente código implementa el algoritmo de ordenamiento por inserción en una aplicación de consola.
namespace OrdenacionXInsercion
{
#region [Bibliotecas de clases]
using System;
using System.Linq;
#endregion
/// <summary>
/// Clase que encapsula la lógica del método de ordenación por inserción.
/// </summary>
public class Program
{
/// <summary>
/// Método de ejecución principal.
/// </summary>
/// <param name="args">Argumentos.</param>
public static void Main(string[] args)
{
Console.WriteLine("Ingresa los numeros a ordenar separados por comas(,) y presiona la tecla Enter.");
int[] vector = Console.ReadLine().Replace(" ","").Split(',').Select(x => Convert.ToInt32(x)).ToArray();
Console.WriteLine();
Console.WriteLine("Vector ordenado:");
Console.WriteLine(string.Join(",", Ordenar(vector)));
Console.WriteLine();
Console.WriteLine("Presiona una tecla para salir.");
Console.ReadKey();
}
/// <summary>
/// Método que implementa el algoritmo de ordenación por inserción a un vector´.
/// </summary>
/// <param name="vector">Vector que contiene los elementos a ordenar.</param>
/// <returns>Vector ordenado.</returns>
private static int[] Ordenar(int[] vector)
{
int auxiliar;
for (int i = 1; i < vector.Length; i++)
{
auxiliar = vector[i];
for (int j = i - 1; j >= 0 && vector[j] > auxiliar; j--)
{
vector[j + 1] = vector[j];
vector[j] = auxiliar;
}
}
return vector;
}
}
}
El siguiente programa es un ejemplo del manejo de objetos en memoria y su gestión a través de una interfaz gráfica de usuario.
Manejo de Objetos.rar (77,64 kb)
Dependencias:
Instalar el siguiente paquete utilizando la consola de Paquetes Nuget
Install-Package Unity -Version 4.0.1
PerRequestLifetimeManager.cs
namespace WebApiClient.App_Start
{
using Microsoft.Practices.Unity;
using System;
using System.Web;
/// <summary>
/// Clase que encapsula la gestión del ciclo de vida de los objetos que son generados
/// por el patron de Inyección de Dependencias.
/// </summary>
public class PerRequestLifetimeManager: LifetimeManager, IDisposable
{
// Clave del storage.
private readonly Guid Key = Guid.NewGuid();
/// <summary>
/// Método que obtiene el objeto que se encuentra activo en el storage.
/// </summary>
/// <returns>Objeto.</returns>
public override object GetValue()
{
if (HttpContext.Current != null && HttpContext.Current.Items.Contains(Key))
return HttpContext.Current.Items[Key];
else
return null;
}
/// <summary>
/// Método para quitar el objeto del storage.
/// </summary>
public override void RemoveValue()
{
if (HttpContext.Current != null)
HttpContext.Current.Items.Remove(Key);
}
/// <summary>
/// Método para almacenar un objeto en el storage.
/// </summary>
/// <param name="newValue">Objeto.</param>
public override void SetValue(object newValue)
{
if (HttpContext.Current != null)
HttpContext.Current.Items[Key] = newValue;
}
/// <summary>
/// Método para liberar los recursos de memoria.
/// </summary>
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
/// <summary>
/// Método para liberar los recursos cuando sea requerido.
/// </summary>
/// <param name="disposing">Valor que indica si se desea liberar los recursos.</param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
RemoveValue();
}
}
}
IoCFactory.cs
namespace WebApiClient.App_Start
{
using Domain.Contracts;
using Infrastructure.Implementation;
using Infrastructure.Persistence;
using Microsoft.Practices.Unity;
using System.Data.Entity;
/// <summary>
/// Clase que encapsula la implementación del patrón de
/// inyección de dependencias e inversión de control para
/// el repositorio genérico y unidad de trabajo.
/// </summary>
public class IoCFactory
{
// Propiedad que encapsula el contenedor.
private static readonly IUnityContainer UnityContainer = new UnityContainer();
// Propiedad que expone el contenedor.
public static IUnityContainer Container { get { return UnityContainer; } }
/// <summary>
/// Método encargado de llevar acabo los patrones de IoC y DI para el repositorio genérico
/// y unidad de trabajo.
/// </summary>
public static void RegisterTypes()
{
UnityContainer.RegisterType(typeof(IRepository<>), typeof(Repository<>));
UnityContainer.RegisterType(typeof(IUnitOfWork), typeof(UnitOfWork));
UnityContainer.RegisterType(typeof(DbContext), typeof(Context));
UnityContainer.RegisterInstance(new DbContextAdapter(UnityContainer.Resolve<DbContext>()), new PerRequestLifetimeManager());
UnityContainer.RegisterType<IObjectSetFactory>(new InjectionFactory(x => x.Resolve<DbContextAdapter>()));
UnityContainer.RegisterType<IObjectContext>(new InjectionFactory(x => x.Resolve<DbContextAdapter>()));
}
}
}
FabricaCategoria.cs
namespace WebApiClient.App_Code.Fabricas
{
using Infrastructure.Contracts;
using Domain.Entities;
/// <summary>
/// Fabrica para controlador de categoría.
/// </summary>
public class FabricaCategoria
{
// Repositorio que encapsula la gestión de categorias.
private IRepository<Categoria> repositorioCategoria;
// Unidad de trabajo.
private IUnitOfWork unidadTrabajo;
// Propiedad publica para recuperar el repositorio de categoría.
public IRepository<Categoria> RepositorioCategoria { get { return repositorioCategoria; }}
// Propiedad publica para recuperar la unidad de trabajo.
public IUnitOfWork UnidadTrabajo { get { return unidadTrabajo; }}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="repositorioCategoria">Repositorio Categoria.</param>
/// <param name="unidadTrabajo">Unidad de Trabajo.</param>
public FabricaCategoria(IRepository<Categoria> repositorioCategoria, IUnitOfWork unidadTrabajo)
{
this.repositorioCategoria = repositorioCategoria;
this.unidadTrabajo = unidadTrabajo;
}
}
}
CategoriaController.cs
namespace WebApiClient.Controllers
{
using Microsoft.Practices.Unity;
using Resources;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Http;
using System.Web.Http.Cors;
using App_Code;
using App_Code.Fabricas;
using App_Start;
/// <summary>
/// Controlador que contiene WebMethods para gestionar la información de las categorías.
/// </summary>
[EnableCors("*", "*", "*")]
public class CategoriaController : BaseController
{
// Variable que encapsula la fabrica para la gestión de categorias.
private FabricaCategoria fabricaCategoria;
/// <summary>
/// Constructor.
/// </summary>
public CategoriaController()
{
fabricaCategoria = IoCFactory.Container.Resolve<FabricaCategoria>();
}
/// <summary>
/// Método para obtener todas las categorías de un tipo.
/// </summary>
/// <param name="tipoCategoriaId">Identificador del tipo de categoría.</param>
/// <returns>HttpResponseMessage que contiene el resultado de la ejecución del método.</returns>
[HttpGet]
public HttpResponseMessage ObtenCategorias(int tipoCategoriaId)
{
try
{
return Request.CreateResponse(HttpStatusCode.OK, fabricaCategoria.RepositorioCategoria.Find(x => x.TipoCategoriaId == tipoCategoriaId && x.Activo).OrderBy(x => x.Nombre).ToList());
}
catch (Exception ex)
{
return Request.CreateResponse(HttpStatusCode.InternalServerError, "No fue posible obtener la información de las categorias.");
}
}
}
}