Managed Extensibility Framework (MEF)

Hi Community,

In last December, I began working on a framework for creating extensible and dynamic code, without being dependant on the DLR, I called this personal project “Simplicity”, as a matter of fact is mentioned on this post. However, I’m currently engaged on a new project, and I need to implement some mechanism to provide that extensibility. So after searching on the Internet plus some guidance provided by a fellow peer, Nathan Fernandez, I was able to find MEF, which it was precisely what I was looking for. Below you can find some links related to MEF:

Regards,

Angel

Marco de Trabajo Administrado para Extensibilidad (MEF)

Hola Comunidad,

En diciembre del año pasado, comencé a trabajar en un marco de trabajo para crear código extensible, dinámico y sin dependencia del DLR, a este proyecto personal lo llamé “Simplicity”, de hecho lo menciono en este post. Sin embargo, actualmente estoy en un proyecto y necesito utilizar algún marco de trabajo que permita ser extensible. Haciendo algo de investigación en la Internet además de la información provista por mi colega Nathan Fernandez, conseguí a MEF lo cual era lo que necesitaba. A continuación unos enlaces sobre MEF:

Saludos,

Angel

UIInspector, dynamic memory allocation and pointer arithmetic

Hi community,

I came back from Melbourne a couple of days ago, to attend and present at DDD Sydney, however, the previous night it was raining heavily and I had to stay at the hotel; so I began to write another demo for my presso and I wrote the  UIInspector, a class that allows to extract information from the children elements within a window  (for instance, a textbox or label). The code snippet is shown below 

   1: public static List<UIElement> GetUIElements(string pidOrImageName) {

   2:             int testPid = 0;

   3:             bool hasData = false;

   4:             string xmlAsString = string.Empty;

   5:             List<UIElement> retval = new List<UIElement>();

   6:             IntPtr uiXml = Marshal.AllocHGlobal(XML_ALLOCATED_BYTES);

   7:             GCHandle pinnedPtr = GCHandle.Alloc(uiXml, GCHandleType.Pinned);

   8:             EnumChildProc enumCallback = new EnumChildProc(EnumChildWindowProcedure);

   9:             GCHandle safeFunctor = GCHandle.Alloc(enumCallback);

  10:             WriteMemory(XML_START, uiXml);

  11:  

  12:             if (int.TryParse(pidOrImageName, out testPid) &&

  13:                 Process.GetProcesses().AsQueryable().Where(x => x.Id.Equals(testPid)).Count() > 0) {

  14:                 using (Process targetProcess = Process.GetProcessById(testPid))

  15:                     EnumChildWindows(targetProcess.MainWindowHandle, (EnumChildProc)safeFunctor.Target, uiXml.ToInt32());

  16:                 hasData = true;

  17:             } else {

  18:                 if (!string.IsNullOrEmpty(pidOrImageName)) {

  19:                     var targetProcess = Process.GetProcessesByName(pidOrImageName).DefaultIfEmpty();

  20:  

  21:                     if (targetProcess.Any()) {

  22:                         EnumChildWindows(targetProcess.First().MainWindowHandle, (EnumChildProc)safeFunctor.Target, uiXml.ToInt32());

  23:                         hasData = true;

  24:                     }

  25:                 }

  26:             }

  27:  

  28:             xmlAsString = Marshal.PtrToStringAnsi(uiXml);

  29:             pinnedPtr.Free();

  30:             safeFunctor.Free();

  31:             Marshal.FreeHGlobal(uiXml);

  32:  

  33:             if (!string.IsNullOrEmpty(xmlAsString) && hasData)

  34:                 retval = ConvertToList(xmlAsString);

  35:  

  36:             return retval;

  37:         }

The aforementioned method, expects to receive a string with a numerical representation (Process Identifier) as well as the name of the process to be inspected. The method returns a List<UIElement> (Struct containing information about the child elements found) which can be filtered through a LINQ query.

The first point of interest in this method is Marshal.AllocHGlobal, which at the same time invokes the VirtualAlloc function, in order to dynamically allocate “these many bytes” in memory (buffer). This is required to avoid  incurring in a potential “C0000005 Exception – Access Violation”, then we have to make use of the GCHandle struct to prevent the GC from moving that memory address, and we do the same with the delegate responsible for enumerating the children elements.

It is well-known that a pointer is just a memory address therefore it’s a number; so it’s not hard to manipulate this memory through pointer arithmetic as shown below:

  • (a_pointer + (a_offset * sizeof(*apointer)))

That formula allows us to write in the following memory address (block) given by a pointer, in “theory” we don’t have pointers in C#, however, there are times where a direct memory mainpulation is required as depicted below

   1: private static void WriteMemory(string stringToWrite, IntPtr memoryAddress) {

   2:     int offset = 0;

   3:  

   4:     if (!string.IsNullOrEmpty(stringToWrite)) {

   5:         stringToWrite.AsEnumerable().ToList().ForEach(x => {

   6:             Marshal.WriteByte(new IntPtr(memoryAddress.ToInt64() + (offset * Marshal.SizeOf(typeof(byte)))), (byte)x);

   7:             offset += 1;

   8:         });

   9:     }

  10: }

The method responsible for extracting information from the children elements is shown below, where a WM_GETTEXT message is sent to the child element based on its hWnd, and its contents is then copied into a buffer that is translated into an Unicode through the Marshal.PtrToStringUni method

   1: private static string GetControlOrWindowText(IntPtr hWnd) {

   2:     string retval = string.Empty;

   3:     IntPtr buffer = Marshal.AllocHGlobal(MAX_TEXT_SIZE);

   4:     SendMessage(hWnd, WM_GETTEXT, new IntPtr(MAX_TEXT_SIZE), buffer);

   5:     retval = Marshal.PtrToStringUni(buffer);

   6:     Marshal.FreeHGlobal(buffer);

   7:  

   8:     return retval;

   9: }

The source code can be fully downloaded from here

Regards,

Angel

UIInspector, reserva dinámica de memoria y aritmética de punteros

Hola comunidad,

Hace un par de días regresé de Melbourne para presentar en DDD Sydney, sin embargo, una noche que me quedé en el hotel porque estaba lloviendo, me pusé a escribir un demo para mi charla y escribí el UIInspector, una clase que permite extraer información de los elementos hijos  de una ventana   (por ejemplo, un cuadro de texto o una etiqueta). A continuación les muestro como funciona

   1: public static List<UIElement> GetUIElements(string pidOrImageName) {

   2:             int testPid = 0;

   3:             bool hasData = false;

   4:             string xmlAsString = string.Empty;

   5:             List<UIElement> retval = new List<UIElement>();

   6:             IntPtr uiXml = Marshal.AllocHGlobal(XML_ALLOCATED_BYTES);

   7:             GCHandle pinnedPtr = GCHandle.Alloc(uiXml, GCHandleType.Pinned);

   8:             EnumChildProc enumCallback = new EnumChildProc(EnumChildWindowProcedure);

   9:             GCHandle safeFunctor = GCHandle.Alloc(enumCallback);

  10:             WriteMemory(XML_START, uiXml);

  11:  

  12:             if (int.TryParse(pidOrImageName, out testPid) &&

  13:                 Process.GetProcesses().AsQueryable().Where(x => x.Id.Equals(testPid)).Count() > 0) {

  14:                 using (Process targetProcess = Process.GetProcessById(testPid))

  15:                     EnumChildWindows(targetProcess.MainWindowHandle, (EnumChildProc)safeFunctor.Target, uiXml.ToInt32());

  16:                 hasData = true;

  17:             } else {

  18:                 if (!string.IsNullOrEmpty(pidOrImageName)) {

  19:                     var targetProcess = Process.GetProcessesByName(pidOrImageName).DefaultIfEmpty();

  20:  

  21:                     if (targetProcess.Any()) {

  22:                         EnumChildWindows(targetProcess.First().MainWindowHandle, (EnumChildProc)safeFunctor.Target, uiXml.ToInt32());

  23:                         hasData = true;

  24:                     }

  25:                 }

  26:             }

  27:  

  28:             xmlAsString = Marshal.PtrToStringAnsi(uiXml);

  29:             pinnedPtr.Free();

  30:             safeFunctor.Free();

  31:             Marshal.FreeHGlobal(uiXml);

  32:  

  33:             if (!string.IsNullOrEmpty(xmlAsString) && hasData)

  34:                 retval = ConvertToList(xmlAsString);

  35:  

  36:             return retval;

  37:         }

El método antes mostrado, espera recibir una cadena con una representación númerica (Identificador del proceso) o el nombre del proceso a inspeccionar, dicho método después retorna una lista de UIElement (Estructura con información del elemento hijo encontrado) la cuál puede filtrarse con una consulta de LINQ.

El primer punto de intéres en dicho método es que usamos el método Marshal.AllocHGlobal que al mismo tiempo llama a la función VirtualAlloc, para así reservar dinámicamente “tantos bytes” de memoria (búfer) para así no incurrir en una posible “excepción C0000005 – Violación de Acceso”, lo siguiente es utilizar la estructura GCHandle para evitar que el GC mueva esa dirección de memoria previamente reservada y haga lo mismo con el delegado que apunta al método responsable por enumerar los elementos (ventanas) hijas.

Como es sabido por todos, un puntero es una dirección en memoria y esta corresponde a un valor númerico; por lo que es válido manipular esa memoria a través de la aritmética de punteros, como mostramos con la siguiente fórmula:

  • (a_pointer + (a_offset * sizeof(*apointer)))

La cual permite escribir en la próxima ubicación de memoria que es dada por un puntero, en C# en “teoría” no se tienen punteros, sin embargo en muchas ocasiones es necesario la manipulación directa de la memoria, como se muestra a continuación

   1: private static void WriteMemory(string stringToWrite, IntPtr memoryAddress) {

   2:     int offset = 0;

   3:  

   4:     if (!string.IsNullOrEmpty(stringToWrite)) {

   5:         stringToWrite.AsEnumerable().ToList().ForEach(x => {

   6:             Marshal.WriteByte(new IntPtr(memoryAddress.ToInt64() + (offset * Marshal.SizeOf(typeof(byte)))), (byte)x);

   7:             offset += 1;

   8:         });

   9:     }

  10: }

El método responsable de extraer el texto de los elementos hijos es el siguiente, en donde se envía un mensaje WM_GETTEXT, y el contenido de dicho elemento es copiado en un  búfer para después convertirla en una cadena Unicode mediante la función Marshal.PtrToStringUni

   1: private static string GetControlOrWindowText(IntPtr hWnd) {

   2:     string retval = string.Empty;

   3:     IntPtr buffer = Marshal.AllocHGlobal(MAX_TEXT_SIZE);

   4:     SendMessage(hWnd, WM_GETTEXT, new IntPtr(MAX_TEXT_SIZE), buffer);

   5:     retval = Marshal.PtrToStringUni(buffer);

   6:     Marshal.FreeHGlobal(buffer);

   7:  

   8:     return retval;

   9: }

El código mostrado se puede descargar completo desde acá

Saludos,

Angel

A comparison of the C++ casting operators

Hi community,

This post is about a feature that’s available in C++, which sometimes tends to confuse developers. I’m referring to casting operators. These operators complement the old C-style casting operator (provided for backwards compatibility), the C++ standard defines the following operators:

  • static_cast: It’s the most useful cast. It can be used to perform any implicit cast. When an implicit conversion loses some information, some compilers will produce warnings, and static_cast will eliminate these warnings. Making implicit conversion through static_cast is also useful to resolve ambiguity or to clarify the conversion presence. It also can be used to call a unary constructor, declared as explicit. It also can be used to cast up and down a class hierarchy, like dynamic_cast, except that no runtime checking is performed.
  • dynamic_cast: It’s used on polymorphic pointers or references to move up or down a class hierarchy. Note that dynamic_cast performs runtime-checks: if the object’s type is not the one expected, it will return NULL during a pointer-cast and throw a std::bad_cast exception during a reference-cast.
  • const_cast: It’s used to apply or remove const or volatile qualifier from a variable.
  • reinterpret_cast: It’s used to perform conversions between unrelated types, like conversion between unrelated pointers (like char* to void*) and references or conversion between an integer and a pointer.

Regards,

Angel

 

Comparación de operadores para conversión forzada de tipos en C++

Hola comunidad,

El siguiente post es acerca de una característica disponible en  C++, la cual tiende a confundir a muchos desarrolladores. Me refiero a los operadores para realizar conversiones forzadas de tipo (casting). Estos operadores complementan al operador ofrecido y tomado de C (el cuál se mantiene por compatibilidad) sin embargo el C++ standard  define los siguientes operadores:

  • static_cast: Éste es el más útil de los operadores. Puede utilizarse para realizar cualquier conversión forzada de tipo implícita. Cuando una conversión implícita pierde información, algunos compiladores generan advertencias, y static_cast elimina estas advertencias. La conversión implícita a través de dicho operador también es útil para resolver la ambigüedad o hacer evidente la presencia de una conversión forzada de tipo. Se puede utilizar también para invocar un constructor unario que se haya declarado como explicit. Así mismo puede ser utilizado para convertir forzosamente el tipo hacia arriba o abajo de la jerarquí de clases, cómo dynamic_cast, excepto que no hay chequeo en el tiempo de ejecución.
  • dynamic_cast: Es utilizado con punteros polimórficos o refeencias que pueden moverse hacia arriba o abajo en la jerarquía de clases. Éste operador realiza chequeos en tiempo de ejecución: Sí el tipo del objeto no es el esperado, entonces retornará NULL durante una conversión forzada de tipo de punteros y arrojará una excepción de tipo std::bad_cast cuando se aplique a una referencia.
  • const_cast: Es utilizado para eliminar los calificadores const y/o volatile de una variable.
  • reinterpret_cast: Es utilizado para realizar conversiones forzadas de tipo entre tipo de datos que no están relacionados, por ejemplo, conversión de tipo entre punteros no relacionados (como char* a void*) o conversiones entre un entero y un puntero.

Saludos,

Angel

 

Developer… Developer… Developer Sydney!

logo[2]

Hi community,

I would like to invite you to “Developer… Developer… Developer Sydney”. This event will be held at Microsoft in North Ryde on Saturday, June 17th. I’ll be presenting “Some survival tips & tricks for developers”. I look forward to seeing you there!!!

Regards,

Angel

 


Hola comunidad,

Me gustaría invitarlos al evento “Developer… Developer… Developer Sydney”. El cual se llevará a cabo en las oficinas de Microsoft en North Ryde, el Sábado 17 de Junio. Estaré presentando “Some survival tips & tricks for developers”. Espero verlos allá!!!

Saludos,

 

Angel

Webcast recording and demos for "What’s new in VS 2010 for C++ developers" / Grabación del webcast y demos de "Lo nuevo en VS2010 para desarrolladores de C++"

Hi Community,


 

Please feel free to download the recording and demos from yesterday’s webcast –  “What’s new in VS 2010 for C++ developers” . It’s in Spanish though [:)] 

 

Regards,

Angel

 


Hola Comunidad,


 

Por favor siéntanse libres de descargar la grabación y demos del webcast de ayer  “Lo nuevo en VS2010 para desarrolladores de C++

 

 

Saludos,

Angel