Work on revised distrib framework begun, started early work on simplifying the process system.
Identified a bug / missing feature in the IOC bootstrapping and argument matching where multiple constructors looking for different interfaces (that are assignable to one another) it didn't do anything because I'd decided initially that multiple constructors wasn't worth the effort to support, the arg matching logic now checks for explicit interface / base type matches before checking assignable matches to ensure the ctor explicitly matching the arguments supplied is chosen.
Binding to a method allows the method expression to get at the parameters passed for the get request, the args at this point have already been through arg matching before being given to the expression so the names should all be there, supports positional access and case-senstive name access.
Oops, argument matching on the bootstrapper actually failed for arguments with names supplied. Also made some changes to locating arguments via their type, an issue arose if the argument was a Type itself and the ctor was looking for a Type, Type.GetType() is a RuntimeType rather than a Type, so that was simply failing to locate the argument, also switched binding to a method to just using a function rather than an expression.
Process & Job builders now working and producing definitions.
Rudimentary inferrence of process definition from a type is now working, allows you to write actual classes without adhering to any interfaces / base classes and use the methods of the class as jobs.
Metadata for jobs and processes now resides in a separate class and accessed via respective metadata interfaces; allows easier separation of metadata and reduces potential clash of arg names for IOC matching.
Added fundamentals of setting up input and output value fields, as well as early work on process bridges; yet to add additional tag data onto process and job definitions so bridges can have per-scenario data (e.g. a process inferred from a type will want to put the method details as tags against the job definitions so the bridge can have that information).
Process and job definitions can now have a key/value data dictionary accompanying them, the builders allow these to be added to, and the factories allow them to be supplied; this is designed to be so whatever generates the definitions (infer from type etc) can push some specifics along with the definitions (e.g. exact method signature for type-inferred jobs so overloads can be supported)
Argument matching logic revised, far from optimal and potentially not complete (tests need adding to ensure real completion), solves problem with old logic where a ctor taking a System.Object parameter after another class type parameter (e.g. the earlier param could also be matched against System.Object as a base-type), this could have been fixed simply by eliminating checks against already matched arguments, but the logic was clunky and needed reworking.
Removed old license details in line with master
Create README.md
Added readme
Type inferred processes are now up and running, they also support passing inputs and outputs via ExpandoObjects which makes working with them so much easier, inputs and outputs can also be any value you want (even funcs and actions), you can even use callbacks via actions etc in your process methods! (of course this flexibility won't necessarily carry across network boundaries because of serialisation)
Merged DistribRevised into master, new process system is ready to roll.