Método de ordenamiento por selección C#

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;
        }
    }
}

Método de ordenamiento por inserción C#

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;
        }
    }
}

Implementación de Patron Repository con IoC y DI en Web API

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.");                
            }            
        }
    }
}