lunes, 25 de marzo de 2013

HTML5 Websockets

Un amigo me hizo conocer Web Sockets, la verdad está buenísimo... Todavía no se mucho del tema, pero me pasó dos links interesantes, y me gustaría compartirlos! contienen explicaciones + ejemplos...

http://html5demos.com/web-socket

http://www.html5rocks.com/es/tutorials/websockets/basics/

Saludos!

sábado, 16 de marzo de 2013

Ventajas MVC vs ASP NET

Como mencioné en el Post anterior, empecé hace poco con MVC. Quiero en este post nombrarles las diferentes ventajas/desventajas que encontré entre MVC y ASP NET.

No voy a describir la arquitectura que plantea MVC, para esto recomiendo que se den una vuelta por wikipedia, san google, y lo que encuentren.

Tampoco voy a describir en detalles el tema de ventajas y desventajas, sino que voy a dar un "pantallazo" (screenshot??).

Aclaración: me surgió un amor repentino a MVC, así que pido disculpas por tal vez no ser tan imparcial en lo que publique a continuación.

Manejo de estilos y scripts
Una característica que me sorprendió de MVC es la manera que tiene de importar los scripts y estilos. A diferencia de ASP NET, a estos archivos los agrupás en "Bundles". Estos bundles, son definidos en un archivo que se encuentra dentro de la carpeta App_Start, en BundleConfig.cs.

Ejemplo:
    public class BundleConfig
    {
        public static void RegisterBundles(BundleCollection bundles)
        {
            bundles.Add(new ScriptBundle("~/bundles/jquery").Include(
                        "~/Scripts/jquery-{version}.js"));

            bundles.Add(new ScriptBundle("~/bundles/jqueryui").Include(
                        "~/Scripts/jquery-ui-{version}.js"));

            bundles.Add(new ScriptBundle("~/bundles/jqueryval").Include(
                        "~/Scripts/jquery.unobtrusive*",
                        "~/Scripts/jquery.validate*"));

            bundles.Add(new ScriptBundle("~/bundles/modernizr").Include(
                        "~/Scripts/modernizr-*"));

            bundles.Add(new StyleBundle("~/Content/css").Include("~/Content/site.css"));

            bundles.Add(new StyleBundle("~/Content/themes/base/css").Include(
                        "~/Content/themes/base/jquery.ui.core.css",
                        "~/Content/themes/base/jquery.ui.resizable.css",
                        "~/Content/themes/base/jquery.ui.selectable.css",
                        "~/Content/themes/base/jquery.ui.accordion.css",
                        "~/Content/themes/base/jquery.ui.autocomplete.css",
                        "~/Content/themes/base/jquery.ui.button.css",
                        "~/Content/themes/base/jquery.ui.dialog.css",
                        "~/Content/themes/base/jquery.ui.slider.css",
                        "~/Content/themes/base/jquery.ui.tabs.css",
                        "~/Content/themes/base/jquery.ui.datepicker.css",
                        "~/Content/themes/base/jquery.ui.progressbar.css",
                        "~/Content/themes/base/jquery.ui.theme.css"));

            // BOOTSTRAP
            bundles.Add(new ScriptBundle("~/bundles/bootstrap").Include("~/Scripts/bootstrap.js"));
            bundles.Add(new StyleBundle("~/Content/css/bootstrap").Include("~/Content/bootstrap.css"));

            // PROPIOS
            bundles.Add(new StyleBundle("~/Content/css/personalized").Include("~/Content/Personalized.css"));
        }
   }

Ese ejemplo es de la definición de los "Bundles", para importarlos, basta con escribir en la "View" (View sería como la parte visual de una página, por llamarlo de alguna manera), en la sección head:


@Styles.Render("~/Content/css/bootstrap")
@Styles.Render("~/Content/css")
@Styles.Render("~/Content/css/personalized")
@Scripts.Render("~/bundles/modernizr")

¿Qué ventajas tiene esto?
Además de evitar escribir 10000 líneas de definiciones de estilos, hay algo muy interesante: cuando publicamos nuestro sitio web, pero en versión "Release", comprime los estilos y scripts, logrando incrementar la velocidad de nuestro sitio web (dado que hace que pese menos), y nos ahorra el molesto trabajo de tener que recurrir a herramientas externas de compresión de JS y CSS.

Razor

Razor me enamoró! sencillamente... no se si será mejor o peor que ASP NET, pero me enamoró... Me gusta muchísimo la sintaxis que tiene, cuando termino de hacer una "View" en Razor me queda un código más comprensible y agradable visualmente que en un archivo ASPX.

Ajax

MVC facilita muchísmo la forma de trabajar con AJAX:

        [HttpGet]
        public ActionResult Product(int? pid)
        {
            if (pid == 0 || pid == null)
                return View("Error");

            var model = new ProductModel();

            using (var db = new ContextAssetRepository())
            {
                model.Asset = db.assetinfo.Find(pid);
            }

            if (model.Asset == null)
                return View("Error, no se ha encontrado ningún asset.");
            else
                return View(model);
        }


El método Product no es más que un método que recibe un parámetro entero por "Get", y devuelve un resultado.

Si deseo que este reciba parámetros por Post, basta con utilizar el atributo [HttpPost].

Qué puedo resaltar de ASP NET?
No se si es que todavía me estoy adaptando a MVC, pero si bien este tiene todas estas ventajas que nombré, siento que no tengo tanto control / dominio sobre lo que hago. Pero como dije, puede ser porque recién empiezo con MVC (dado que cuando pasé de C++ a C# tuve esta misma sensación, que luego se extinguió).

---

Bueno, espero que este post haya sido de ayuda. Si desean que lo amplíe, modifique o mejore, no duden en contactar conmigo o dejarme un comentario abajo.

Saludos!!

Sincronizar proyecto MVC3 con base de datos MS SQL 2008 (u otra)

Hola gente! les cuento, hace poco empecé con MVC4. Lo que hoy quise hacer era utilizando una base de datos ya creada en SQL Server 2008, cargarla en mi proyecto MVC4 (con Entity Framework), y poder utilizar los datos de una de las tablas. Comencé a buscar, encontré muchísimos artículos, pero el que más me sirvió es el siguiente, espero que les sea de utilidad: http://msdn.microsoft.com/en-us/data/gg685489.aspx Saludos!

lunes, 4 de marzo de 2013

[C#] Delegados e Invoke

Aquí mostraré un código para hacer Invoke sin necesidad de andar pre-definiendo delegados. El uso del Invoke se hace para llamar a métodos que están en un hilo diferente al del contexto actual. Por ejemplo, puede ser utilizado para actualizar un elemento de un Form, desde el evento Tick de un Timer.
public partial class FormTest: Form
{
    public FormTest()
    {
        InitializeComponent();
    }

    private void FormTest_Load(object sender, EventArgs e)
    {
        this.Invoke((MethodInvoker)delegate(){
            MessageBox.Show("Este es mi método!");
        });
    }
}
Saludos!