Parse C# functions from JSON files

Question

I'm messing around with game item implementations, and to avoid hard-coding the items, I'd like to load their information and implementations from external files.

The basic format would be something like this:

-- Items.json
[
    {
        "name": "Rusty Key",
        "shortDesc": "A rusty key.",
        "longDesc": "A slightly rusty key. You don't know what door it opens.",
        "code": "RustyKey.cs"
    }
]

OR embed the Use() code directly into the JSON file:

-- Items.json
[
    {
        "name": "Rusty Key"
        ...
        "use": "return 0;"
    }
]

The JSON file would be loaded at runtime and dynamically add the items as well as their implementations.

This could also perhaps morph into a simple scripting language allowing players to create their own items, but in its current form I would not release it to the public due to the potential for abuse.

So my question is this: how can I load/parse the attached script file OR embedded code and attach it to the dynamically-created object?

Answer 1

Create MyLibrary.dll and add following code:

namespace MyTypesNamespace
{

    public abstract class BaseItem
    {
        public abstract bool Use(object onMyObject);
    }

    public class Door
    {
        public bool IsLocked { get; set; }

        public bool Open()
        {
            if (IsLocked)
            {
                System.Console.WriteLine("Cannot open door. It is locked!");
                return false;
            }

            //Some code
            System.Console.WriteLine("Door is opened!");
            return true;
        }
    }
}

In your main project, add reference to MyLibrary.dll and the following method:

private static List<BaseItem> loadItems(string fromCode)
{
    CodeDomProvider codeProvider = new CSharpCodeProvider();

    // add compiler parameters
    CompilerParameters compilerParams = new CompilerParameters();
    compilerParams.CompilerOptions = "/target:library /optimize";
    compilerParams.GenerateExecutable = false;
    compilerParams.GenerateInMemory = true;
    compilerParams.IncludeDebugInformation = false;
    compilerParams.ReferencedAssemblies.Add("mscorlib.dll");
    compilerParams.ReferencedAssemblies.Add("System.dll");
    compilerParams.ReferencedAssemblies.Add("MyLibrary.dll");

    // compile the code
    CompilerResults results = codeProvider.CompileAssemblyFromSource(compilerParams, fromCode);
    var items = new List<BaseItem>();
    foreach (var itemType in results.CompiledAssembly.DefinedTypes)
    {
        ConstructorInfo ctor = itemType.GetConstructor(Type.EmptyTypes);
        object instance = ctor.Invoke(null);
        items.Add(instance as BaseItem);
    }
    return items;
}

Usage:

private static void Main()
{
    string code =  loadCode();
    List<BaseItem> items = loadItems(code);

    BaseItem rustyKey = items[0];
    BaseItem unlockAnyDoor = items[1];

    Door myDoor = new Door { IsLocked = true };
    rustyKey.Use(myDoor);
    unlockAnyDoor.Use(myDoor);
    rustyKey.Use(myDoor);


    Console.ReadLine();
}

private static string loadCode()
{
    return @"
        using MyTypesNamespace;
        public class RustyKey : BaseItem
        {
            public override bool Use(object onMyObject)
            {
                var door = onMyObject as Door;

                return door.Open();
            }
        }

        public class UnlockAnyDoor : BaseItem
        {
            public override bool Use(object onMyObject)
            {
                var door = onMyObject as Door;
                door.IsLocked = false;
                System.Console.WriteLine(""Door is unlocked!"");
                return true;
            }
        }
";
}

Output: (See the output online)

Cannot open door. It is locked!
Door is unlocked!
Door is opened!

---

Edit:

You can simplify future code supply (which will be read from file) by eliminating code duplication. Let's generateItemClass method which will take className and body of Use() method:

private static string generateItemClass(string className, string useBody)
{
    return $@"
        public class {className} : BaseItem
        {{
            public override bool Use(object onMyObject)
            {{
                {useBody}
            }}
        }}";
}

Don't forget to add using MyTypesNamespace; for all classes.

private static string loadCode()
{
    string namespaces = @"using MyTypesNamespace;";

    string rustyKeyClass = generateItemClass("RustyKey",
        @"var door = onMyObject as Door;
        return door.Open();");

    string unlockAnyDoorClass = generateItemClass("UnlockAnyDoor",
        @"var door = onMyObject as Door;
        door.IsLocked = false;
        System.Console.WriteLine(""Door is unlocked!"");
        return true;");

    return namespaces + rustyKeyClass + unlockAnyDoorClass;
}

Answer 2

Putting raw code into JSON means having to pick up that code, probably parse it, glue it into some code shell, compile it and check for errors. That's a lot of machinery. (Another answer pretty provides details to do this).

There's also the problem that if somebody can write arbitrary code there, they will, and they will write something that breaks your application in arbitrarily strange ways, either creating a security leak or if nothing else some difficult debugging problems.

I think you'd be better off in most cases simply signalling what you want in the JSON, e.g.,

-- Items.json
[
    {
        "name": "Rusty Key"
        ...
        "result": "0"
    }
]

Now the program logic reads the JSON file, stores <"RustyKey","0"> into a hashed lookup collection, and then when a request for RustyKey comes up, looks up the result value in the collection.

Granted, you cannot do as many complicated things as with include code, but you'll get into a lot less trouble.

Motto: "eval is evil".