Mejorando como programador

Leyendo cosas de Carlos Ble, ha escrito sobre un sitio, para mejorar como programador.

String.Empty vs ""

Estudiando LessFramework, me he encontrado que para incializar las cadenas de texto, hace uso de String.Empty.

string callingMethod = String.Empty;

Me ha entrado la curiosidad y he estado googleando, para ver la razón que hay detrás, me he encontrado una página, que dice que es más eficiente String.Emtpy, porque no crea un objeto (es un mñetodo estático) y por lo tanto se ahorra memoria, pero en cambio con "", se crea un objeto y tiene que ponerlo en la pila de los objetos, por lo tanto afecta algo (muy muy poco) al rendimiento.

Unix desde AT&T

Me he encontrado un video que cuenta la historia de Unix y la página es de la propia AT&T

El código que me encuentro en el trabajo

Me pregunto si realmente somo buenos programadores o nos merecenos lo que tenemos.
Porque viendo este código ya me entran las dudas. Eso sí, sigo con ganas de seguir mejorando como programador, porque si no tuviera estas ganas de aprender, seguro que generaría este código o aún peor. Un compañero de profesión me dijo una vez que él escribía el código todo seguido ...

       private void AplicarContorno(Control control, bool aplicar)
        {
            var canvas = (Canvas)control.FindName("Canvas");
            foreach (var poligono in canvas.Children)
            {
                try
                {
                    var path = (Path)poligono;
                    if (aplicar)
                    {
                        path.Stroke = Brushes.Black;
                    }
                    else
                    {
                        path.Stroke = Brushes.Transparent;
                    }
                }
                catch (Exception)
                {
                    try
                    {
                        var canvas2 = (Canvas)poligono;
                        if (canvas2 != null)
                        {
                            foreach (var municipio in canvas2.Children)
                            {
                                var path2 = (Path)municipio;
                                if (aplicar)
                                    path2.Stroke = Brushes.Black;
                                else
                                    path2.Stroke = Brushes.Transparent;
                            }
                        }
                    }
                    catch
                    {
                    }
                }
            }
        }

ASP.NET MVC

Cuando se comienza a conocer una tecnología, uno está muy perdido, por lo menos es lo que me pasa ahora que me ha dado por estudiar MVC y mi olfato me dice que las cosas van a ir por aquí. Mirando cosas sobre este tema, me he encontrado un video, que da una buena visión (esa es mi sensación), para montar un proyecto con testa tecnología.
Espero que sea utilidad.
Me he dado cuenta de que hay más videos.

Una forma distinta de ver las horas

Enlace

Fichero de Log Asíncrono

Hablando con algunos compañeros de trabajo, estábamos debatiendo sobre emplear ficheros de log. Soy firme defensor de ello, porque ante un error en producción, hay que conocer el porqué del fallo. El problema que nos encontrábamos era que al hacer uso de ficheros de log, la fvelocidad, disminuía muchísmo. así que buscando un poco he pensado que una buena solución es generar los ficheros de log de forma asíncrona. Se emplean las EnterPriseLibrary, porque para qué reinventar la rueda, por lo tanto no hay que olvidar la .dll.

using Microsoft.Practices.EnterpriseLibrary.Logging;



namespace ClassLibrary1

{

    public class Log

    {

        delegate void WriteLogDelegate(string message);



        public static void WriteLog(string message)

        {

            WriteLogDelegate logDelegate = new WriteLogDelegate(AsyncWriteLog);

            AsyncHelper.FireAndForget(logDelegate, message);

        }



        static void AsyncWriteLog(string message)

        {

            LogEntry log = new LogEntry();

            log.Message = message;



            Logger.Write(log);

        }       

       

    }

}

using System;



namespace ClassLibrary1

{

    /// <summary>

    /// This is asynchronous helper class from Jon Skeet

    /// http://www.yoda.arachsys.com/csharp/threads/threadpool.shtml

    /// </summary>

    public class AsyncHelper

    {

        /// <summary>

        /// Delegate to wrap another delegate and its arguments

        /// </summary>

        delegate void DelegateWrapper(Delegate d, object[] args);



        /// <summary>

        /// An instance of DelegateWrapper which calls InvokeWrappedDelegate,

        /// which in turn calls the DynamicInvoke method of the wrapped

        /// delegate.

        /// </summary>

        static DelegateWrapper wrapperInstance = new DelegateWrapper(InvokeWrappedDelegate);



        /// <summary>

        /// Callback used to call <code>EndInvoke</code> on the asynchronously

        /// invoked DelegateWrapper.

        /// </summary>

        static AsyncCallback callback = new AsyncCallback(EndWrapperInvoke);



        /// <summary>

        /// Executes the specified delegate with the specified arguments

        /// asynchronously on a thread pool thread.

        /// </summary>

        public static void FireAndForget(Delegate d, params object[] args)

        {

            // Invoke the wrapper asynchronously, which will then

            // execute the wrapped delegate synchronously (in the

            // thread pool thread)

            wrapperInstance.BeginInvoke(d, args, callback, null);

        }



        /// <summary>

        /// Invokes the wrapped delegate synchronously

        /// </summary>

        static void InvokeWrappedDelegate(Delegate d, object[] args)

        {

            d.DynamicInvoke(args);

        }



        /// <summary>

        /// Calls EndInvoke on the wrapper and Close on the resulting WaitHandle

        /// to prevent resource leaks.

        /// </summary>

        static void EndWrapperInvoke(IAsyncResult ar)

        {

            try

            {

                wrapperInstance.EndInvoke(ar);

                ar.AsyncWaitHandle.Close();

            }

            catch (Exception ex)

            {

                //Handle the exception.

            }

        }

    }

}

También hay que crear un fichero de configuración, que en este caso se llama: App.config y el contenido es:

<?xml version="1.0" encoding="utf-8"?>

<configuration>

  <configSections>

    <section name="loggingConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.LoggingSettings, Microsoft.Practices.EnterpriseLibrary.Logging, Version=3.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />

  </configSections>

  <loggingConfiguration name="Logging Application Block" tracingEnabled="true"

    defaultCategory="General" logWarningsWhenNoCategoriesMatch="true">

    <listeners>

      <add fileName="SVPBuildTool.log" rollSizeKB="0" timeStampPattern="yyyy-MM-dd"

        rollFileExistsBehavior="Increment" rollInterval="Day" formatter="Text Formatter"

        header="----------------------------------------" footer="----------------------------------------"

        listenerDataType="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.RollingFlatFileTraceListenerData, Microsoft.Practices.EnterpriseLibrary.Logging, Version=3.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"

        traceOutputOptions="None" type="Microsoft.Practices.EnterpriseLibrary.Logging.TraceListeners.RollingFlatFileTraceListener, Microsoft.Practices.EnterpriseLibrary.Logging, Version=3.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"

        name="Rolling Flat File Trace Listener" />

    </listeners>

    <formatters>

      <add template="Timestamp: {timestamp}&#xD;&#xA;Message: {message}&#xD;&#xA;Category: {category}&#xD;&#xA;Priority: {priority}&#xD;&#xA;EventId: {eventid}&#xD;&#xA;Severity: {severity}&#xD;&#xA;Title:{title}&#xD;&#xA;Machine: {machine}&#xD;&#xA;Application Domain: {appDomain}&#xD;&#xA;Process Id: {processId}&#xD;&#xA;Process Name: {processName}&#xD;&#xA;Win32 Thread Id: {win32ThreadId}&#xD;&#xA;Thread Name: {threadName}&#xD;&#xA;Extended Properties: {dictionary({key} - {value}&#xD;&#xA;)}"

        type="Microsoft.Practices.EnterpriseLibrary.Logging.Formatters.TextFormatter, Microsoft.Practices.EnterpriseLibrary.Logging, Version=3.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"

        name="Text Formatter" />

    </formatters>

    <categorySources>

      <add switchValue="All" name="General">

        <listeners>

          <add name="Rolling Flat File Trace Listener" />

        </listeners>

      </add>

    </categorySources>

    <specialSources>

      <allEvents switchValue="All" name="All Events">

        <listeners>

          <add name="Rolling Flat File Trace Listener" />

        </listeners>

      </allEvents>

      <notProcessed switchValue="All" name="Unprocessed Category" />

      <errors switchValue="All" name="Logging Errors &amp; Warnings" />

    </specialSources>

  </loggingConfiguration>

</configuration>