Mis más y menos con los parámetros ref en las llamadas a COM en C# 4

Una de las cuatro áreas principales en las que se agrupan las novedades de C# 4.0 presentadas en la recién finalizada PDC es la relacionada con la simplificación de la programación en C# contra librerías COM, personificadas generalmente en las API subyacentes a las diferentes aplicaciones que componen la suite Office: Word, Excel, Outlook y compañía. Hasta el momento, la programación en C# contra estos “modelos de objetos” era realmente una tarea farragosa.


Cuando estas novedades estén en vigor, la creación programática de un documento de Word, que en C# 3.0 había que expresar de la siguiente forma:



namespace WordDemo
{
   using Word = Microsoft.Office.Interop.Word;
   class Program
   {
      static void Main(string[] args)
      {
         object o_null = System.Reflection.Missing.Value;
         object o_endOfDoc = “\endofdoc”;
         object o_fileName = “c:\temp\HelloWorld.rtf”;
         object o_format = Word.WdSaveFormat.wdFormatRTF;
         object o_false = false;
         Word.ApplicationClass app = new Word.ApplicationClass();
         Word.Document doc = app.Documents.Add(ref o_null, ref o_null, ref o_null, ref o_false);
         Word.Range rng = doc.Bookmarks.get_Item(ref o_endOfDoc).Range;
         rng.InsertAfter(“Hello, world”);
         doc.SaveAs(ref o_fileName, ref o_format,
            ref o_null, ref o_null, ref o_null, ref o_null,
            ref o_null, ref o_null, ref o_null, ref o_null,
            ref o_null, ref o_null, ref o_null, ref o_null,
            ref o_null, ref o_null);
         app.Quit(ref o_false, ref o_null, ref o_null);
      }
   }
}


podrá reducirse a lo siguiente:



namespace WordDemo
{   
    using Word = Microsoft.Office.Interop.Word;   


    class Program   
    {       
        static void Main(string[] args)       
        {           
            Word.ApplicationClass app = new Word.ApplicationClass();           
            Word.Document doc = app.Documents.Add(Visible: false);
            Word.Range rng = doc.Bookmarks.get_Item(“\endofdoc”).Range;           
            rng.InsertAfter(“Hello, world”);
            doc.SaveAs(“c:\temp\HelloWorld.rtf”, Word.WdSaveFormat.wdFormatRTF);           
            app.Quit(false);       
        }   
    }
}


Además de las dos nuevas características que ya hemos presentado antes (los parámetros opcionales y nombrados), a la reducción significativa de la cantidad de código en este ejemplo contribuye una tercera: la posibilidad de omitir la declaración e inicialización de una variable y el uso del modificador ref en los parámetros por referencia de las llamadas. En lugar de:



object o_endOfDoc = “\endofdoc”; 
Word.Range rng = doc.Bookmarks.get_Item(ref o_endOfDoc).Range;


bastará con escribir:



Word.Range rng = doc.Bookmarks.get_Item(“\endofdoc”).Range;


El compilador se encargará de crear e inicializar por nosotros una variable temporal y pasarla al método por referencia.


A esto, en principio, se le podría encontrar mucho sentido: el paso por referencia se utiliza con mucha frecuencia en la “programación nativa” no por la necesidad de modificar el parámetro, sino en aras de una mayor eficiencia o flexibilidad (o simplemente porque se le antojó al creador de la librería :-). Pero esto seguramente no ocurre en el 100% de los casos, por lo que el programador que hago uso de esta característica deberá estar advertido – o mucho me equivoco, o el compilador no le avisará.


Lo otro que no me gusta de esta nueva característica es que solo puede utilizarse si la llamada es a un método COM importado, lo cual rompe en principio con la ortogonalidad del lenguaje, algo que yo creo que jamás haría si el lenguaje fuera mío (por suerte para todos, no lo es :-). No obstante, casi todos los discursos o escritos de representantes de Microsoft que he visto hasta el momento coinciden en que las novedades de C# 4 tienen una naturaleza práctica y están orientadas a simplificar y agilizar la obtención de resultados. Y en el marco de ese importante objetivo, ¿qué importancia puede tener un detalle más bien relacionado con la estética?


Casualmente, en el momento en que comencé a escribir este post estaba terminando de leer la novela póstuma del gran escritor cubano Guillermo Cabrera Infante, “La ninfa inconclusa”, que recomiendo sinceramente a todo el mundo, aunque tal vez especialmente a mis compatriotas – la novela contiene tantas referencias culturales a La Habana y a la idiosincrasia cubana que alguien no versado en ellas seguramente disfutará menos con la lectura. Leí una frase en el libro que instintivamente conecté con este post:



El esteticismo es el último refugio del fracaso de la vida


Una observación que suena un poco drástica, sin dudas, pero no exenta de cierta razón. Así que ¡que venga C# 4!


 

Octavio Hernandez

Desarrollador y consultor en tecnologías .NET. Microsoft C# MVP entre 2004 y 2010.

5 comentarios en “Mis más y menos con los parámetros ref en las llamadas a COM en C# 4

  1. Comparto lo que dices de la ortogonalidad y es una argumento fuerte, pero habiendo picado muchas líneas de COM con ATL y VB 6.0, es una carácteristica a la que doy una calurosa bienvenida.

    ¡Un saludo maestro!

  2. >Pero esto seguramente no ocurre en el 100% de los casos, por lo que el programador que hago uso de esta característica deberá estar advertido – o mucho me equivoco, o el compilador no le avisará.

    Como diria Rafa: Nos acercamos un poquito más a C xDDDD

    Saludos!

  3. ¡Ya he llegadoooooooo! 🙂

    Pues la verdad es que no sé cómo se me ha escapado esta entrada, porque te tengo pinchado en las RSS generales de Geeks y directamente… Hum… será para que no despotrique… 🙂

    Ahora que lo miro en detalle… ¡Es como en C++! ¡No tienes que decir nada especial para pasar argumentos por referencia! Si al final ya verás: toítos calcaos de C++. 🙂

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *