public DocTopic ParseClass(DotnetObject obj, DocTopic parentTopic)
{
var topic = new DocTopic(_project)
{
Title = $"{obj.FormattedName} Class",
//ListTitle = obj.FormattedName,
DisplayType = "classheader",
ClassInfo = new ClassInfo
{
MemberName = obj.Name,
Signature = obj.Signature,
RawSignature = obj.RawTypeName,
Namespace = obj.Namespace,
Scope = obj.Scope,
Syntax = obj.Syntax,
Implements = obj.Implements,
Inherits = obj.InheritsFrom,
InheritanceTree = obj.InheritanceTree,
Classname = obj.FormattedName,
Assembly = obj.Assembly,
},
Remarks = obj.Remarks,
Example = obj.Example,
SeeAlso = obj.SeeAlso,
};
topic.Parent = parentTopic;
topic.CreateRelativeSlugAndLink(topic);
topic.Body = obj.HelpText;
parentTopic?.Topics.Add(topic);
foreach (var meth in obj.Methods.Where(m => m.IsConstructor))
{
var childTopic = ParseMethod(meth, topic);
parentTopic.Topics.Add(childTopic);
}
foreach (var meth in obj.Methods.Where(m => !m.IsConstructor).OrderBy(m => m.Name))
{
var childTopic = ParseMethod(meth, topic);
parentTopic.Topics.Add(childTopic);
}
foreach (var prop in obj.Properties.OrderBy(p => p.Name))
{
var childTopic = ParseProperty(prop, topic);
parentTopic.Topics.Add(childTopic);
}
//foreach (var ev in obj.Events)
//{
// var childTopic = ParseEvent(ev, parentTopic);
// parentTopic.Topics.Add(childTopic);
//}
return(topic);
}
void RenderType(DotnetObject type)
{
Console.WriteLine($"{type} - - {type.Signature}");
if (type.Properties.Count > 0)
{
Console.WriteLine(" *** Properties:");
foreach (var prop in type.Properties)
{
Console.WriteLine($"* {prop} - {prop.Signature} - {prop.Type}");
Console.WriteLine($"{prop.HelpText}");
Console.WriteLine("---");
}
}
}
private Object getStaticMember(string key)
{
var members = ClassType.GetMembers(BindingFlags.Static | BindingFlags.Public);
var target = (from member in members
where ((member.MemberType == MemberTypes.Field ||
member.MemberType == MemberTypes.Property ||
member.MemberType == MemberTypes.Method ||
member.MemberType == MemberTypes.NestedType) &&
member.Name == key)
select member);
Object result = null;
if (target.Any())
{
MemberInfo memberInfo = target.First();
MemberTypes memberTypes = memberInfo.MemberType;
if (memberTypes == MemberTypes.Property)
{
result = new DotnetObject
((memberInfo as PropertyInfo).GetValue(null));
}
else if (memberTypes == MemberTypes.Field)
{
result = new DotnetObject
((memberInfo as FieldInfo).GetValue(null));
}
else if (memberTypes == MemberTypes.NestedType)
{
result = new DotnetClass
{
ClassType = memberInfo as Type
};
}
else
{
result = new DotnetMethod
{
Target = null,
Type = ClassType,
methodName = key
};
}
}
return(result);
}
public override Object Invoke(List <Object> callParams)
{
List <Type> types = new List <Type>();
List <object> targetParams = DotnetObject.toObjects(callParams);
foreach (var aparam in targetParams)
{
types.Add(aparam.GetType());
}
MethodInfo method = Type.GetMethod(methodName, types.ToArray());
object result = method.Invoke(Target, targetParams.ToArray());
if (result is null)
{
return(null);
}
return(DotnetObject.toScriptObject(Engine, result));
}
public override void setItem(string key, Object value)
{
if (GetMember(key) is MemberInfo member)
{
MemberTypes type = member.MemberType;
if (type == MemberTypes.Method)
{
throw new System.Exception("You can't assign it to a function.");
}
else if (type == MemberTypes.Field)
{
Type.GetField(key).SetValue(Target, DotnetObject.toObject(value));
}
}
else
{
base.setItem(key, value);
}
}
public override Object Create(List <Object> ctorParams)
{
object instance = Activator.CreateInstance(ClassType, DotnetObject.toObjects(ctorParams).ToArray());
return(new DotnetObject(instance));
}
private void loadGlobal()
{
RootContext["Clr"] = new DotnetNamespace();
RootContext["Object"] = new ObjectPrototype();
RootContext["System"] = new DotnetObject(new SystemClass());
}
