C＃-如何在Dotfuscator.Net中使用匿名类型？

Question

I have this piece of code in my C# application:

JObject personJson = JObject.FromObject(
    new
    {
        name = "John Doe",
        age = 34,
        height = 1.78,
        weight = 79.34
    });

Console.WriteLine(person);

And it logs:

{
    "name": "John Doe",
    "age": 34,
    "height": 1.78,
    "weight": 79.34
}

And the Dotfuscater obfuscates it to this:

Console.WriteLine((object) JObject.FromObject((object) new global::b<string, int, double, double>("John Doe", 34, 1.78, 79.34)));

And then the output is this:

{}

How can I use anonymous classes with the Dotfuscator without this problem?

EDIT:

Full code:

public static class Example
{
    static void LogPerson()
    {
        JObject personJson = JObject.FromObject(
            new
            {
                name = "John Doe",
                age = 34,
                height = 1.78,
                weight = 79.34
            });
        Console.WriteLine(JSONObject);
    }
}

Answer 1

I see that no one has replied to your post, so I thought I would respond with some thoughts. You probably already know these things, so I apologize ahead of time.

First, I see that from the obfuscated code, that the returned object from JObject.FromObject is being cast to an object type. Remember that if you pass any object reference to the Console.WriteLine method, the object's default ToString method will be called. Consequently, Object.ToString() method is being called in your example. From the MSDN documentation for Object.ToString() it states:

Default implementations of the Object.ToString method return the fully qualified name of the object's type.

I would say that your use of an anonymous type is confusing things in a way I do not know of; but could you write a custom ToString extension method for the JObject type? Maybe something akin to:

public static class Extensions
{
    public static string ToJSONString(this JObject jo)
    {
        // You could step into this method in the VS debugger to
        // see what 'jo' looks like. You may have to use reflection
        // to get at the properties, but I've never tried it on an 
        // anonymous type. 
    }
}

You would then call Console.WriteLine(JSONObject.ToJSONString()); BTW, the use of JSONObject as the name of a variable confuses me because it looks like a Type ; could you use jsonObject instead?

I hope someone else can clarify things a bit more. Good Luck!

Answer 2

You/I could use a dynamic object, like this:

dynamic person = new ExpandoObject();
person.name = "John Doe";
person.age = 34;
person.height = 1.78;
person.weight = 79.34;

JObject personJson = JObject.FromObject(person);

Console.WriteLine(personJson);

It looks very weird when it's obfuscated but it does work. The output is exactly as expected.

Answer 3

It looks like Dotfuscator is removing the properties even though you don't want it to. (It does that because usually it's harmless, and it makes reverse-engineering harder.) You should be able to exclude those properties from renaming, which will prevent them from being removed, by configuring an exclude rule that matches the CompilerGeneratedAttribute . That will prevent all such properties on anonymous classes from being removed.

Here's an example of a project file (segment) that would do this:

<excludelist>
  <type name=".*" regex="true" excludetype="false">
    <customattribute name=".*CompilerGeneratedAttribute" regex="true" />
    <propertymember name=".*" regex="true" />
  </type>
</excludelist>

You can read about how to do this via the GUI in the Community Edition docs or Pro docs .

Full disclosure: I work for PreEmptive Solutions.