Windows 8 Metro App - How to debug JS that was loaded at runtime

In the last period of time I had to work a lot with JavaScript and not for the UI, but for an entire Metro application on Windows 8. One of the nice features of JavaScript is the ability to access any kind of function and defining or overriding functions at runtime.
This feature is very powerful but also can create a lot of mess. In this moment if we would try to write a C# Metro Application we would not have the ability to load at runtime any kind of assembly or code. The “reflection” part on the .NET framework for Metro Application is not the one that we know from the normal .NET.
In JavaScript if we have a script like this:

(function(){
    “use strict”
    WinJS.Namespace.define(“MyClass”,{
    doSomeAction: function(){
        console.warn(“doSomeAction was called”);
}
});
})();

we could evaluate the script at runtime and call or instanced the object and functions that were defined.
The first step is to evaluate the script. Let assume that the definition of this script can be found in a string field named “source”. All we need to do to load this script is to call the “window.execScript” method.

var source = “ our code “;
window.execScript(source);

After this step we can call our classes and functions from our code like this:

MyClass.DoSomeAction();

Wow, very simple. In C# this would not be some simple, but the true is that I would never want to do something like this in C#. Maybe loading an assembly at runtime but this is all that I would like to do.
One big question for you now. How we can debug the code that is loaded dynamically?
You would say that it is not possible. We cannot put a breakpoint in the code that is loaded dynamically. In C# we have a method that stops the code and popup a message to the user to attach a debugger. In JavaScript this is possible using “debugger”. In every place where framework finds a debugger, the execution of code will stop like we would have a breakpoint.
We saw how we can load dynamic code at runtime how we can debug it. This is a powerful feature but be aware. Loading code at runtime is not the best thing do to when we talk about performance. Also a lot of security issues can appear. This can be the tool of devil :-).

Read More

How to get friendly format for GetType().Name

Pornim de la urmatorul exemplu:

List<string> list = new List<string>();
Console.WriteLine(list.GetType().Name);

Asa cum ne-am astepta ne este returnat "List`1". Dar uneori nu ne este de ajuns atata, vrem sa vedem si tipul generci. Ceva de genul acesta "List". Pentru acest lucru avem nevoie sa apelam metoda GetGenericArguments pentru a obtine tipuriile generice.
Mai jos gasiti un extension method la Type care returneaza numele la type asa cum l-am prezentat mai sus.

public static class TypeExtensions
{
private const string TypeSeparator=",";
private const char UnusedSymbol = '`';
private const string TypeFormat = "{0}<{1}>";

public static string ToGenericTypeString(this Type type)
{
    if (!type.IsGenericType)
    {
        return type.Name;
    }

    return string.Format(TypeFormat,
                GetGenericTypeName(type),
                GetGenericArgumentsName(type));
}

private static string GetGenericArgumentsName(Type type)
{
    return string.Join(
            TypeSeparator,
            type.GetGenericArguments()
                    .Select(ToGenericTypeString).ToArray());
}

private static string GetGenericTypeName(Type type)
{
    string typeName =type.GetGenericTypeDefinition().Name;
    return typeName.Substring(0, typeName.IndexOf(UnusedSymbol));
}
}

Enjoy!

Read More

Access a property using reflection

Cum putem face get/set la o proprietate prin intermediul la reflection. Odata ce avem tipul obiectului care contine proprietate, este de ajuns sa apelam InvokeMember si sa specificam numele proprietatii.

private TReturn GetProperty<TReturn>(object obj, string propertyName)
{
    return (TReturn) obj.GetType().InvokeMember(
                    propertyName,
                    BindingFlags.GetProperty,
                    null,
                    obj,
                    null);
}

private void SetProperty(object obj, string propertyName, object value)
{
    obj.GetType().InvokeMember(
            propertyName,
            BindingFlags.SetProperty,
            null,
            obj,
            new object[] { value });
}

BindingsFlags se poate seta printr-un OR logic, in functie de proprietatea cu care lucram( publica, privata, statica, etc). De exemplu, pentru o proprietate publica si care nu este statica putem sa avem urmatorul apel:

 obj.GetType().InvokeMember(
            propertyName,
            BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetProperty,
            Type.DefaultBinder,
            obj,
            new object[] { value });

O alta modalitate de a lucra cu proprietati este sa obtim o instanta la PropertyInfo pentru proprietatea noastra, iar apoi sa facem get/set pe aceasta in felul urmator:

PropertyInfo propertyInfo = obj.GetType().GetProperty(propertyName);
propertyInfo.SetValue(obj, value, null);

Nu trebuie sa uitam ca numele la proprietate este case-sensitive.
Am incercat sa compar accesul direct la o proprietate cu cel prin reflection pentru 100.000.000 de accesari. Accesul proprietatilor prin reflection este cu circa 150 de ori mai lent decat prin accesul direct a unei proprietati. Per secunda, am avut circa ~145.000.000 de iteratii pe secunda pentru accesul direct in comparatie cu circa ~940.000.000 de iteratii pe secunde pentru accesul prin reflection.
Dar codul care folosea reflection nu a fost deloc optimizat. O sa revin cu un post in care o sa facem o optimizare a codului care foloseste reflection.
Enjoy!

Read More

Adnotare enum cu mai multe valori

Cand dorim sa serializam un enum putem sa atasam la valoarea fiecarui item din enum atributul XmlEnumAttribute. Astfel la serializare/deserializare o sa putem lucra cu o valoarea string nu cu o valoare numerica.
Pana aici nici o problema, dar cum facem sa obtinem doar aceasta valoarea si nu un xml care contine si aceasta valoarea . De exemplu pentru enum-ul:

public enum Dimension
{
    [XmlEnum(Name="BigT")]
    Big
    [XmlEnum(Name="SmallT")]
    Small   
}

am obține folosindu-ne de XmlSerializer un output care contine si un nod care specifica ce tip de data ii. Pentru a putea sa obtinem doar valoare BigT sau SmallT putem sa apelam la reflection si sa iteram prin atributele item-ului respectiv pana ajungem la un atribut de tip XmlEnumAttribute.
Acuma, daca ducem problema umpic mai departe, putem sa ajungem la cazuri in care elementele din enum au diferite valori. De exemplu daca lucram cu doua sau mai multe aplicații, putem sa avem doua sau mai multe reprezentări pentru aceiasi valoare. De exemplu o aplicație poate sa isi noteze valoare Big cu BigT, iar alta cu BigState. La prima strigare putem sa scriem un swith, iar in funcție de sistemul de unde preluam sau trimitem date sa avem o anumita valoare.
O solutie mai generala este sa scriem doua metode care sa stie sa convertească un string intr-un enum in functie de valoarea atributelor cu care adnotam un anumit item din enum. De exemplu in exemplul dat mai sus putem sa avem:

public enum Dimension
{
    [FirstSystem("BigT")]
    [SecondSystem("BigState")]
    Big
    [FirstSystem(Name="SmallT")]
    [SecondSystem("SmallState")]
    Small   
}

In felul acesta, putem sa avem oricate valori pentru un anum. Atributele custom pe care le-am definit trebuie sa mosteneasca din clasa XmlEnumAttribute. Se poate scrie si un atribut custom, dar am folosit aceasta clasa deoarece deja continea o valoare de tip string.
Mai jos gasiti doua metode care ne permit sa convertim un enum in string si viceversa pe baza atributelor. Pentru a putea obtine valorea unui atribut este nevoie sa iteram prin toata lista de atribute pana ajungem la atributul pe care noi il dorim.

 public static string GetAttributeValue<TAttribute>(Enum @enum)
            where TAttribute: XmlEnumAttribute
        {
            Type enumType = @enum.GetType();
            Type attributeType = typeof (TAttribute);
            FieldInfo info = enumType.GetField(@enum.ToString("G"));
            if (!info.IsDefined(typeof(XmlEnumAttribute), false))
            {
                return @enum.ToString("G");
            }

            foreach (var customAttribute in info.GetCustomAttributes(attributeType, false))
            {
                if (customAttribute.GetType() == attributeType)
                {
                    XmlEnumAttribute attribute = (XmlEnumAttribute)customAttribute;
                    return attribute.Name;
                }
            }
          
            throw new Exception("The given attribute could not be found.");
        }

     
        public static TEnum GetEnumByAttributeValue<TEnum,TAttribute>(string value)
            where TAttribute: XmlEnumAttribute
        {
            Type enumType = typeof(TEnum);

            foreach (var item in Enum.GetValues(enumType))
            {
                 if(GetAttributeValue<TAttribute>((Enum)item)==value)
                 {
                     return (TEnum)Enum.Parse(enumType, item.ToString());
                 }
            }

            throw new IndexOutOfRangeException(string.Format("The {0} attribute value cannot be found on the {1} enum", value, enumType.Name));
        }

Read More