IDisposable Thoughts

Algo que es bien recurrente y hasta “básico” en muchas de nuestras aplicaciones es el cálculo de la edad para una fecha dada. Tomando esto en cuenta y aprovechando a nuestros amigos los métodos de extensión me cree un par de métodos sencillos que pueden más de algún día salvarnos un par de minutos.

using System;
using Xunit;
using Xunit.Extensions;

namespace Rioshu.Educa.Facts
{
    public class DateTimeExtensionFacts
    {
        [Fact]
        public void Can_calculate_age_with_simple_dates()
        {
            var past_date = DateTime.Now.AddYears(-10);
            Assert.Equal(10, past_date.Age());
        }

        [Fact, FreezeClock(2009, 01, 01)]
        public void Can_calculate_age_with_not_so_simple_dates()
        {
            var past_date = new DateTime(2002, 02, 13);

            Assert.Equal(7, past_date.Age());
        }

        [Fact]
        public void Can_calculate_age_with_a_base_date()
        {
            var from_date = new DateTime(2010, 01, 01);
            var past_date = new DateTime(2002, 02, 13);

            Assert.Equal(8, past_date.Age(from_date));
        }
    }
}

Y aquí la implementación del helper

    public static class DateTimeExtensions
    {
        public static int Age(this DateTime date)
        {
            return Age(date, DateTime.Now);
        }

        public static int Age(this DateTime date, DateTime from_date)
        {
            if (from_date.Month <= date.Month && from_date.Day < date.Day) {
                return from_date.Year - date.Year - 1;
            }

            return from_date.Year - date.Year;
        }
    }

Como siempre acepto sugerencias y comentarios Hasta la próxima!

Es común en aplicaciones web trabajar con imágenes y hacer una que otra simple operación (cambiar el tamaño de una imagen, cambiar el formato de una imagen, obtener el MimeType de una imagen, cosas como esas).

Como duplicar código es lo peor que uno puede hacer, aproveché la simempre útili ayuda de los Extension Methods para estas simples operaciones, se los comparto a todos

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

namespace Rioshu.Utils.Drawing
{
    public static class ImageExtensions
    {
        public static Image ToSize(this Image image, int width, int height)
        {
            var resized_image = new Bitmap(width, height);
            using (var graphics = Graphics.FromImage(resized_image)) {
                graphics.DrawImage(image, 0, 0, width, height);
            }

            return resized_image;
        }

        public static Image ToSize(this Image image, int size)
        {
            var max_side = image.Width > image.Height ? image.Width : image.Height;
            var factor = (float) size/max_side;

            var new_width = Convert.ToInt32(factor*image.Width);
            var new_height = Convert.ToInt32(factor*image.Height);

            return ToSize(image, new_width, new_height);
        }

        public static Image ToFormat(this Image image, ImageFormat format)
        {
            var memory_stream = new MemoryStream();
            image.Save(memory_stream, format);

            return new Bitmap(memory_stream);
        }

        public static byte[] GetBytes(this Image image)
        {
            var memory_stream = new MemoryStream();
            image.Save(memory_stream, image.RawFormat);
            var content = new byte[memory_stream.Length];
            memory_stream.Seek(0, SeekOrigin.Begin);
            memory_stream.Read(content, 0, content.Length);

            return content;
        }

        public static string GetMimeType(this Image image)
        {
            foreach (var codecInfo in ImageCodecInfo.GetImageDecoders()) {
                if (codecInfo.FormatID == image.RawFormat.Guid) {
                    return codecInfo.MimeType;
                }
            }
            return "image/unknown";
        }
    }
}

La forma de usarlos es sumamente fácil, basta con un simple ejemplo:

// digamos que leemos un archivo o stream que contiene una imagen
var image = Image.FromStream(file_stream).ToSize(125, 125);
// Resto de las operaciones de imagen

Espero le sea de ayuda a mas de alguien. Saludos!