public TypeCollection ReflectOnAssembly(Assembly assembly, IncludeKind includeKind)
{
TypeCollection typeCollection = new TypeCollection();
Type[] types = assembly.GetTypes();
foreach (Type type in types)
{
// Skip any classes they don't want us to include.
IncludeKind currentIncludeKind = type.IsPublic ? IncludeKind.Public : IncludeKind.Internal;
if ((currentIncludeKind & includeKind) == 0)
{
continue;
}
// Skip compiler-generated classes, which are invisible to both
// consumers of the assembly and to the assembly's creator.
if (type.Name.StartsWith("<"))
{
continue;
}
TypeDoc typeDoc = ConvertTypeToDocForm(type, includeKind);
typeCollection = typeCollection.AddType(typeDoc.Name, typeDoc);
}
return(typeCollection);
}
//// N: = Namespace
//// T: = Type i.e. class, interface, struct, enum or delegate
//// F: = Field
//// P: Property
//// E: Event
//// I: error unresolved construct
public DocumentationHelper(string path)
{
var documentation = XDocument.Load(path);
var typeDocs = new List <TypeDoc>();
var methodDocs = new List <MethodDoc>();
var fieldDocs = new List <FieldDoc>();
foreach (var element in documentation.Descendants("member"))
{
var name = element.Attribute("name")?.Value ?? string.Empty;
if (name.StartsWith("T:"))
{
var newType = new TypeDoc(element);
typeDocs.Add(newType);
methodDocs.AddRange(newType.Methods);
fieldDocs.AddRange(newType.Fields);
}
}
Types = typeDocs;
Methods = methodDocs;
Fields = fieldDocs;
}
private static TypeDoc _GenerateTypeDoc(TypeInfo typeInfo, List <XmlDocumentation> comments, string fileName)
{
var link = LinkCache.SetLink(typeInfo.CSharpName(), typeInfo.Name, fileName);
link.Markdown = typeInfo.Name;
var doc = new TypeDoc {
AssociatedType = typeInfo.AsType()
};
var typeComment = comments.FirstOrDefault(c => c.MemberName == typeInfo.FullName &&
c.MemberType == MemberType.Type);
doc.Tags.AddRange(typeComment.Data.Select(_ConvertToTag));
var memberComments = typeInfo.GetAllMembers()
.Where(m => m.IsPublic())
.Join(comments,
m => _GetMemberName(typeInfo, m),
c => c.MemberName,
(m, c) => new { Member = m, Comment = c });
doc.Members.AddRange(memberComments.Select(mc => _ConvertToMember(mc.Member, mc.Comment, fileName)));
return(doc);
}
public ActionResult DeleteConfirmed(string id)
{
TypeDoc typeDoc = db.TypeDoc.Find(id);
db.TypeDoc.Remove(typeDoc);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "Id,Code_Type,Description")] TypeDoc typeDoc)
{
if (ModelState.IsValid)
{
db.Entry(typeDoc).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(typeDoc));
}
public frmDocGrid(TypeDoc parTypeDoc)
{
dt = Global.cBL.LoadDocs(parTypeDoc);
InitializeComponent();
if (Global.eTypeTerminal == TypeTerminal.BitatekIT8000)
{
this.WindowState = FormWindowState.Maximized;
}
InitializeComponentManual();
}
private TypeCollection ConnectTheDots()
{
foreach (MethodDoc method in _methods.Values)
{
NameInfo className = method.Name.Parent;
if (!_types.TryGetValue(className, out TypeDoc typeDoc))
{
typeDoc = _types[className] = new TypeDoc(className);
}
_types[className] = typeDoc = typeDoc.AddMethod(method.Name.NameWithParameters, method);
}
foreach (FieldDoc field in _fields.Values)
{
NameInfo className = field.Name.Parent;
if (!_types.TryGetValue(className, out TypeDoc typeDoc))
{
typeDoc = _types[className] = new TypeDoc(className);
}
_types[className] = typeDoc = typeDoc.AddField(field.Name.NameWithParameters, field);
}
foreach (PropertyDoc property in _properties.Values)
{
NameInfo className = property.Name.Parent;
if (!_types.TryGetValue(className, out TypeDoc typeDoc))
{
typeDoc = _types[className] = new TypeDoc(className);
}
_types[className] = typeDoc = typeDoc.AddProperty(property.Name.NameWithParameters, property);
}
foreach (EventDoc @event in _events.Values)
{
NameInfo className = @event.Name.Parent;
if (!_types.TryGetValue(className, out TypeDoc typeDoc))
{
typeDoc = _types[className] = new TypeDoc(className);
}
_types[className] = typeDoc = typeDoc.AddEvent(@event.Name.NameWithParameters, @event);
}
ImmutableDictionary <NameInfo, TypeDoc> typeDictionary = ImmutableDictionary <NameInfo, TypeDoc> .Empty;
foreach (TypeDoc type in _types.Values)
{
typeDictionary = typeDictionary.Add(type.Name, type);
}
return(new TypeCollection(typeDictionary));
}
public ActionResult Create([Bind(Include = "Id,Code_Type,Description")] TypeDoc typeDoc)
{
if (ModelState.IsValid)
{
db.TypeDoc.Add(typeDoc);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(typeDoc));
}
public static string Version(this TypeDoc doc)
{
var matches = VersionRegEx.Matches(doc.FullName);
if (matches[0].Groups.Count == 3)
{
return(matches[0].Groups[1].Value + "." + matches[0].Groups[2].Value);
}
return(string.Empty);
}
private void ParseMember(XElement element)
{
string name = element.AttributeOrDefault("name")?.Trim();
if (string.IsNullOrEmpty(name) || name.Length < 2 || name[1] != ':')
{
return;
}
char kind = name[0];
NameInfo nameInfo = new NameParser().Parse(name.Substring(2), kind == 'M');
switch (kind)
{
case 'T':
TypeDoc typeDoc = new TypeDoc(nameInfo,
ParseMeta(element),
typeParameters: ParseTypeParameters(element));
_types.Add(typeDoc.Name, typeDoc);
break;
case 'M':
MethodDoc methodDoc = new MethodDoc(nameInfo,
ParseMeta(element),
ParseTypeParameters(element),
ParseParameters(element),
ParseExceptions(element));
_methods.Add(methodDoc.Name, methodDoc);
break;
case 'F':
FieldDoc fieldDoc = new FieldDoc(nameInfo,
ParseMeta(element));
_fields.Add(fieldDoc.Name, fieldDoc);
break;
case 'P':
PropertyDoc propertyDoc = new PropertyDoc(nameInfo,
ParseMeta(element),
ParseExceptions(element));
_properties.Add(propertyDoc.Name, propertyDoc);
break;
case 'E':
EventDoc eventDoc = new EventDoc(nameInfo,
ParseMeta(element),
ParseExceptions(element));
_events.Add(eventDoc.Name, eventDoc);
break;
}
}
// GET: TypeDocs/Delete/5
public ActionResult Delete(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TypeDoc typeDoc = db.TypeDoc.Find(id);
if (typeDoc == null)
{
return(HttpNotFound());
}
return(View(typeDoc));
}
private void btnNewDocGrid(TypeDoc typeDoc)
{
try
{
frmDocGrid formDocGrid = new frmDocGrid(typeDoc);
formDocGrid.Show();
}
catch (Exception ex)
{
string er = ex.Message;
// ViSoft.Common.clsException.EnableException(ex);
}
finally
{
// this.Text = ViSoft.Common.clsCommon.PropProgramCaption;
}
}
public string RenderMembers(TypeDoc doc)
{
var sb = new StringBuilder();
RenderAutoGeneratedComment(sb);
RenderList(sb, doc.Properties.OrderBy(p => p.Name), "Properties");
if(doc.Methods.Any()) {
RenderNewLine(sb);
RenderList(sb, doc.Methods.OrderBy(m => m.Name), "Methods", ExtenderDoc.BuildMethodSignature);
}
if(doc.Events.Any()) {
RenderNewLine(sb);
RenderList(sb, doc.Events.OrderBy(e => e.Name), "Events");
}
return sb.ToString();
}
private TypeDoc ConvertTypeToDocForm(Type type, IncludeKind includeKind)
{
NameInfo typeName = ConvertTypeToNameInfo(type);
IEnumerable <TypeParameterDoc> typeParameters = ExtractTypeParameters(type);
ImmutableDictionary <string, FieldDoc> fields = ExtractFields(type, typeName, includeKind);
ImmutableDictionary <string, PropertyDoc> properties = ExtractProperties(type, typeName, includeKind);
ImmutableDictionary <string, EventDoc> events = ExtractEvents(type, typeName, includeKind);
ImmutableDictionary <string, MethodDoc> methods = ExtractMethods(type, typeName, includeKind);
ImmutableDictionary <string, MethodDoc> constructors = ExtractConstructors(type, typeName, includeKind);
methods = methods.AddRange(constructors);
TypeDoc typeDoc = new TypeDoc(typeName, null,
typeParameters, fields, properties, events, methods);
return(typeDoc);
}
public string RenderMembers(TypeDoc doc)
{
var sb = new StringBuilder();
RenderAutoGeneratedComment(sb);
RenderList(sb, doc.Properties.OrderBy(p => p.Name), "Properties");
if (doc.Methods.Any())
{
RenderNewLine(sb);
RenderList(sb, doc.Methods.OrderBy(m => m.Name), "Methods", ExtenderDoc.BuildMethodSignature);
}
if (doc.Events.Any())
{
RenderNewLine(sb);
RenderList(sb, doc.Events.OrderBy(e => e.Name), "Events");
}
return(sb.ToString());
}
public static TypeDom Build(TypeDoc doc, AssemblyDom asm, Func <MemberDom, bool> filterMembers)
{
var ret = new TypeDom
{
Assembly = asm,
DocInfo = doc.DocInfo,
Type = doc.ReflectionType,
};
MemberDom[] members = doc.Members
.Where(_ => _.ReflectionMemberInfo != null)
.Select(_ => MemberDom.Build(ret, _.ReflectionMemberInfo, _.DocInfo))
.ToArray();
members = members.Where(
_ => (filterMembers == null || filterMembers(_)) && !_.IsPrivateOrInternal
).ToArray();
ret.AllMembers = members;
ret.Constructors = members.OfType <ConstructorDom>().OrderBy(_ => _.ShortSignature).ToArray();
ret.Fields = members.OfType <FieldDom>()
.OrderBy(_ => _.ShortSignature)
.ToArray();
ret.Properties = members.OfType <PropertyDom>()
.OrderBy(_ => _.ShortSignature)
.ToArray();
ret.Methods = members.OfType <MethodDom>()
.Where(_ => !_.IsOperator)
.OrderBy(_ => _.ShortSignature)
.ToArray();
ret.Operators = members.OfType <MethodDom>()
.Where(_ => _.IsOperator)
.OrderBy(_ => _.ShortSignature)
.ToArray();
ret.Events = members.OfType <EventDom>()
.OrderBy(_ => _.ShortSignature)
.ToArray();
ret.GenericTypeParameters = GenericParameterDom.BuildTypeGenericParameters(ret.Type, ret.DocInfo);
return(ret);
}
private static string LoadingFileReturnFirstImage(List <IFormFile> files, Case userCase)
{
string urlImage = "";
if (files != null)
{
files.ForEach(file =>
{
TypeDoc typeFile = TypeFile(file);
if (typeFile == TypeDoc.IMG)
{
urlImage = file.FileName;
}
userCase.Docs.Add(new Doc()
{
DateAdd = DateTime.Now, URL = file.FileName, Type = typeFile
});
});
}
return(urlImage);
}
//Если попадаются members у которых включающий их класс не был объявлен в XML документации, то создается класс, но у него не будет заполнено RawNode
static TypeDoc[] ParseMembers(XElement members)
{
Dictionary<string, TypeDoc> types = members
.XPathSelectElements("member[starts-with(@name,\"T:\")]")
.Select(TypeDoc.Parse)
.Where(t => !t.FullName.Contains("XamlGeneratedNamespace"))
.ToDictionary(_ => _.FullName);
foreach (var node in members.XPathSelectElements("member[not(starts-with(@name,\"T:\"))]"))
{
var member = MemberDoc.ParseMember(node);
if (member != null)
{
TypeDoc type;
if (types.TryGetValue(member.Name.FullClassName, out type))
{
type.Members.Add(member);
}
else
{
type = new TypeDoc { FullName = member.Name.FullClassName };
type.Members.Add(member);
if (!type.FullName.Contains("XamlGeneratedNamespace"))
types.Add(type.FullName, type);
}
}
else
{
//ToDo: сделать обработку типов(редкие,неиспользуемые) 'N'-namespace, '!' - error
}
}
return types
.Select(_ => _.Value)
.ToArray();
}
/// <summary>
///
/// </summary>
/// <param name="asm"></param>
/// <param name="findOptions"> Опции указывающие какие типы и члены собирать</param>
/// <param name="unboundTypes">Массив типов из XML документации, которые не смогли привязаться к данным из Reflection</param>
/// <param name="unboundMembers">Массив members из XML документации, которые не смогли привязаться к данным из Reflection</param>
public void MergeWithReflection(Assembly asm, FindOptions findOptions, out TypeDoc[] unboundTypes, out MemberDoc[] unboundMembers)
{
var docTypes=Types.ToDictionary(_ => _.FullName);
foreach (var type in asm.GetTypes())
{
if(!type.IsVisible && !findOptions.InternalClasses)
continue;
string name = type.FullName.Replace('+', '.'); //Для nested классов type.FullName дает Class1+Class2, а по XML Class1.Class2 - невозможно отличить nested класс от namespace
TypeDoc docT;
if (docTypes.TryGetValue(name, out docT))
{
if(docT.ReflectionType!=null)
throw new Exception("multiple types on single node");
docT.ReflectionType = type;
}
else if (findOptions.UndocumentedClasses)
{
docT = new TypeDoc { FullName = name , ReflectionType = type};
if (!docT.FullName.Contains("XamlGeneratedNamespace"))
docTypes.Add(docT.FullName, docT);
}
}
if (findOptions.UndocumentedClasses)
Types = docTypes.Select(_ => _.Value).ToArray();
unboundTypes = Types.Where(_ => _.ReflectionType == null).ToArray();
if (unboundTypes.Length > 0)
Types = Types.Where(_ => _.ReflectionType != null).ToArray();
var unbound = new List<MemberDoc>();
foreach (var type in Types)
unbound.AddRange(type.MergeMembersWithReflection(!findOptions.UndocumentedMembers, findOptions.PrivateMembers));
unboundMembers = unbound.ToArray();
}
private static void _GenerateMarkdown(StringBuilder builder, TypeDoc typeDoc)
{
if (!Options.UseGitHubPagesLinks)
{
builder.Header(1, typeDoc.AssociatedType.CSharpName());
}
_GenerateMarkdown(builder, typeDoc.Tags, "summary");
if (typeDoc.AssociatedType.IsGenericType)
{
var generic = typeDoc.AssociatedType.GetGenericTypeDefinition();
var typeParamTags = typeDoc.Tags.OfType <TypeParamTag>().ToList();
foreach (var parameter in generic.GetTypeInfo().GenericTypeParameters)
{
_GenerateMarkdown(builder, parameter, typeParamTags);
}
}
builder.Paragraph($"**Assembly:** {Path.GetFileName(typeDoc.AssociatedType.Assembly.Location)}");
builder.Paragraph($"**Namespace:** {typeDoc.AssociatedType.Namespace}");
// TODO : list base type & implementations
var currentType = typeDoc.AssociatedType;
var list = new List <string>();
while (currentType != null)
{
list.Add($"- {currentType.CSharpName()}");
currentType = currentType.BaseType;
}
list.Reverse();
builder.Paragraph($"**Inheritance hierarchy:**");
foreach (var baseClass in list)
{
builder.AppendLine(baseClass);
}
builder.AppendLine();
_GenerateMarkdown(builder, typeDoc.Tags);
IEnumerable <MemberDoc> sortedMembers = typeDoc.Members;
if (!typeDoc.AssociatedType.IsEnum)
{
sortedMembers = typeDoc.Members
.OrderBy(m => !m.AssociatedMember.IsStatic())
.ThenBy(m => m.AssociatedMember.Name);
}
var groupedMembers = sortedMembers.GroupBy(m => m.MemberType)
.SortBy(SortByKeys, g => g.Key);
foreach (var docGroup in groupedMembers)
{
if (!docGroup.Any())
{
continue;
}
builder.Header(2, docGroup.Key.ToString().Pluralize());
foreach (var member in docGroup)
{
switch (member.AssociatedMember)
{
case PropertyInfo property:
_GenerateMarkdown(builder, property, member.Tags.ToList());
break;
case FieldInfo field:
_GenerateMarkdown(builder, field, member.Tags);
break;
case MethodInfo method:
_GenerateMarkdown(builder, method, member.Tags);
break;
case ConstructorInfo constructor:
_GenerateMarkdown(builder, constructor, member.Tags);
break;
case EventInfo @event:
_GenerateMarkdown(builder, @event, member.Tags);
break;
}
_GenerateMarkdown(builder, member.Tags.OfType <ExceptionTag>());
_GenerateMarkdown(builder, member.Tags.Where(t => !t.Handled));
}
}
}
/// <summary>
/// Load registry and RF
/// </summary>
private void LoadRegistryRF()
{
// if protocol or simplified protocol
if (TypeDoc.Equals("p") || TypeDoc.Equals("psempl"))
{
DocsPaWR.Registro reg = null;
if (TypeDoc.Equals("p"))
{
//get protocol registry
reg = RegistryManager.GetRegistryInSession();
}
else
{
//simplified protocol
}
this.DdlRegRf.Items.Add(new ListItem()
{
Text = reg.codRegistro, Value = string.Empty, Selected = true
});
//I take the RF associated with the registry protocol
Registro[] listRF = RegistryManager.GetListRegistriesAndRF(UIManager.RoleManager.GetRoleInSession().systemId, "1", reg.systemId);
if (listRF != null && listRF.Length > 0)
{
/*I value della combo dei registri sono formati da terne separate dal carattere "_":
* nella prima posizione viene specificata la systemId dell'RF
* nella seconda posizione 0 per gli RF abilitati, 1 per gli RF non abilitati
* nella terza posizione viene specificato l'IdAooCollegata (solo per gli RF)
*/
ListItem[] listItemRF = (from rf in listRF
select new ListItem()
{
Text = rf.codRegistro,
Value = rf.systemId + "_" + rf.rfDisabled + "_" + rf.idAOOCollegata
}).ToArray();
if (listItemRF != null && listItemRF.Length > 0)
{
foreach (ListItem li in listItemRF)
{
li.Attributes.Add("style", "margin-left:10px;");
}
this.DdlRegRf.Items.AddRange(listItemRF);
}
Stack <Registro> stackRegistries = new Stack <Registro>(listRF);
stackRegistries.Push(reg);
this.ObjectRegistryList = stackRegistries.ToArray();
}
else
{
this.ObjectRegistryList = new Registro[] { reg };
}
}
else // case gray documents and search
{
this.DdlRegRf.Items.Add(new ListItem()
{
Text = "TUTTI", Value = string.Empty, Selected = true
});
Registro[] ListRegistriesAndRF = RegistryManager.GetListRegistriesAndRF(UIManager.RoleManager.GetRoleInSession().systemId, string.Empty, string.Empty);
var PairRegRF = (from reg in ListRegistriesAndRF
where reg.chaRF.Equals("0")
select(new
{
IdReg = reg.systemId,
CodReg = reg.codRegistro,
ListItemRF =
(from rf in ListRegistriesAndRF
where rf.idAOOCollegata == reg.systemId
select new ListItem()
{
Text = rf.codRegistro, Value = rf.systemId + "_" + rf.rfDisabled + "_" + rf.idAOOCollegata
}).ToArray()
}));
if (PairRegRF != null)
{
foreach (var RegAssRF in PairRegRF)
{
this.DdlRegRf.Items.Add(new ListItem()
{
Text = RegAssRF.CodReg, Value = RegAssRF.IdReg
});
if ((RegAssRF.ListItemRF as ListItem[]) != null && (RegAssRF.ListItemRF as ListItem[]).Length > 0)
{
foreach (ListItem li in (RegAssRF.ListItemRF as ListItem[]))
{
li.Attributes.Add("style", "margin-left:10px;");
}
this.DdlRegRf.Items.AddRange(RegAssRF.ListItemRF as ListItem[]);
}
}
}
this.ObjectRegistryList = ListRegistriesAndRF;
}
}
protected void btnInsert_Click(object sender, EventArgs e)
{
ScriptManager.RegisterStartupScript(this.Page, this.GetType(), "function", "<script>reallowOp();</script>", false);
try
{
string errMsg = string.Empty;
DocsPaWR.Oggetto oggetto = new DocsPaWR.Oggetto();
DocsPaWR.Registro registro = new DocsPaWR.Registro();
#region Validators
//check on insert of the object
if (string.IsNullOrEmpty(this.TxtDescObject.Text.Trim()))
{
errMsg = "ErrorObjectNoObject";
ScriptManager.RegisterStartupScript(this, this.GetType(), "ErrorObjectNoObject", "parent.ajaxDialogModal('" + errMsg + "', 'warning', 'ATTENZIONE');", true);
return;
}
//check over the length of the object (up to 2000 characters.)
if (this.TxtDescObject.Text.Length > Convert.ToInt32(this.MaxLenghtObject))
{
errMsg = "ErrorObjectLength";
ScriptManager.RegisterStartupScript(this, this.GetType(), "ErrorObjectLength", "parent.ajaxDialogModal('" + errMsg + "', 'warning', 'ATTENZIONE');", true);
return;
}
#endregion
//replace single quotes
oggetto.descrizione = this.TxtDescObject.Text.Trim();// .Replace("'", "''"); Escape viene fatto dai WS
//Adding the object code if there
if (!string.IsNullOrEmpty(this.TxtCodObject.Text.Trim()))
{
oggetto.codOggetto = this.TxtCodObject.Text.Trim(); // .Replace("'", "''"); Escape viene fatto dai WS
}
else
{
oggetto.codOggetto = "";
}
if (this.DdlRegRf.SelectedItem.Value.Equals(""))
{
if (TypeDoc.Equals("p")) // protocol
{
registro = RegistryManager.GetRegistryInSession(); //get protocol registry
registro.codice = this.DdlRegRf.SelectedItem.Text;
}
else if (TypeDoc.Equals("psempl"))
{
// simplified protocol
registro = new Registro();
}
else
{
registro = null;
errMsg = "ErrorRegisterNotSelected";
ScriptManager.RegisterStartupScript(this, this.GetType(), "ErrorRegisterNotSelected", "parent.ajaxDialogModal('" + errMsg + "', 'warning', 'ATTENZIONE');", true);
return;
}
}
else
{
registro.systemId = this.DdlRegRf.SelectedValue.Split('_').First();
registro.codice = this.DdlRegRf.SelectedItem.Text;
}
/*
* if (!string.IsNullOrEmpty(this.TxtCodObject.Text.Trim()))
* {
* if ((from obj in ObjectstListAll where obj.codOggetto.Equals(this.TxtCodObject.Text.Trim()) && obj.codRegistro.Equals(registro.codice) select obj).Count() > 0)
* {
* errMsg = "ErrorObjectCodePresent";
* ScriptManager.RegisterStartupScript(this, this.GetType(), "ErrorObjectCodePresent", "parent.ajaxDialogModal('" + errMsg + "', 'warning', 'ATTENZIONE');", true);
* return;
* }
* }
* if ((from obj in ObjectstListAll where obj.descrizione.Equals(this.TxtDescObject.Text.Trim()) && obj.codRegistro.Equals(registro.codice) select obj).Count() > 0)
* {
* errMsg = "ErrorObjectVoicePresent";
* ScriptManager.RegisterStartupScript(this, this.GetType(), "ErrorObjectVoicePresent", "parent.ajaxDialogModal('" + errMsg + "', 'warning', 'ATTENZIONE');", true);
* return;
* }
*/
oggetto = ObjectManager.AddObject(this, oggetto, registro, ref errMsg);
if (oggetto != null)
{
oggetto.codRegistro = registro.codice;
List <Oggetto> listObj = new List <Oggetto>();
listObj.Add(oggetto);
/*
* List<Oggetto> l = ObjectstListAll.ToList<Oggetto>();
* l.Add(oggetto);
* ObjectstListAll = l.ToArray<Oggetto>();
* */
this.GridSearchObject.DataSource = listObj;
this.GridSearchObject.DataBind();
this.GridSearchObject.SelectedIndex = 0;
this.GridSearchObject.Visible = true;
this.BtnOk.Enabled = true;
this.ObjectBtnDelete.Enabled = true;
this.UpPnlButtons.Update();
this.UpdPnlGridSearch.Update();
}
else
{
if (string.IsNullOrEmpty(this.TxtCodObject.Text.Trim()))
{
errMsg = "ErrorObjectCodeObjectPresent";
ScriptManager.RegisterStartupScript(this, this.GetType(), "ErrorObjectCodeObjectPresent", "parent.ajaxDialogModal('" + errMsg + "', 'warning', 'ATTENZIONE');", true);
}
else
{
errMsg = "ErrorObjectPresent";
ScriptManager.RegisterStartupScript(this, this.GetType(), "ErrorObjectPresent", "parent.ajaxDialogModal('" + errMsg + "', 'warning', 'ATTENZIONE');", true);
}
}
}
catch (System.Exception ex)
{
UIManager.AdministrationManager.DiagnosticError(ex);
}
}
public static void Main(string[] args)
{
try {
// load .dll files in the current directory to
foreach (var file in Directory.GetFiles(Environment.CurrentDirectory, "*", SearchOption.AllDirectories))
{
if (file.ToLowerInvariant().EndsWith(".dll"))
{
Assembly.LoadFile(file);
}
}
foreach (var file in Directory.GetFiles(Environment.CurrentDirectory, "*", SearchOption.AllDirectories))
{
if (file.ToLowerInvariant().EndsWith(".xml"))
{
string xmlStr = File.ReadAllText(file);
xmlStr = Regex.Replace(xmlStr,
"<see cref=\"[A-Z?]:(.*)\" \\/>",
m => "<a href=\"#" +
m.Groups[1].Value.ToLower().Replace('.', '-') + "\">" +
m.Groups[1].Value.Split('.').Last() +
"</a>"
);
xmlStr = Regex.Replace(xmlStr,
@"<(c|code)>([^<])*<\/(c|code)>",
m => "<" +
m.Groups[1].Value +
">" +
m.Groups[2].Captures.Join() +
"</" +
m.Groups[1].Value +
">"
);
using (var stream = xmlStr.ToStream()) {
// TODO: Add reflection stuff, to:
// * determine if properties has setters or only getters
using (var xml = System.Xml.XmlReader.Create(stream)) {
while (xml.Read())
{
if (xml.IsStartElement())
{
BaseDoc CurrentDoc = null;
switch (xml.Name)
{
case "assembly":
CurrentAssembly = new AssemblyDoc();
CurrentDoc = CurrentAssembly;
break;
case "name":
xml.Read();
CurrentAssembly.Name = xml.Value;
reflectedAssembly = AppDomain.CurrentDomain.GetAssemblies().ToList().First(a => a.GetName().Name == xml.Value);
break;
case "member":
var memberName = xml["name"];
char type = memberName[0];
if (memberName.Contains("Hooks"))
{
PreviousDoc = null;
break;
}
switch (type)
{
case 'T':
CurrentDoc = new TypeDoc(CurrentAssembly);
CurrentType = CurrentDoc;
reflectedType = reflectedAssembly.GetType(memberName.Substring(2));
break;
case 'P':
case 'F':
if (CurrentType == null || !memberName.Contains(CurrentType.Name.Substring(2)))
{
string typename = memberName.GetTypeName();
CurrentType = new TypeDoc(CurrentAssembly)
{
Name = typename
};
reflectedType = reflectedAssembly.GetType(typename);
}
// if type == p => add property documentation else => add field doc.
CurrentDoc = type == 'P' ? (new PropertyDoc(CurrentType as TypeDoc)
{
Name = memberName.Substring(2),
Type = (from pinfo in reflectedType.GetProperties()
where pinfo.Name == memberName.GetMemberName()
select pinfo.PropertyType).FirstOrDefault()
} as BaseDoc)
: (new FieldDoc(CurrentType as TypeDoc)
{
Name = memberName.Substring(2),
Type = (from finfo in reflectedType.GetFields()
where finfo.Name == memberName.GetMemberName()
select finfo.FieldType).FirstOrDefault()
} as BaseDoc);
break;
case 'M':
// check if the method is a method of the _current_ type, if it's not then it means the type of this method is not _documented_
// so we add an empty doc for it here
if (CurrentType == null || !memberName.Contains(CurrentType.Name.Substring(2)))
{
string typename = memberName.GetTypeName();
CurrentType = new TypeDoc(CurrentAssembly)
{
Name = typename
};
reflectedType = reflectedAssembly.GetType(typename);
}
reflectedMethodParams = new List <Type>();
string methodname = memberName.GetMemberName();
string paramtypes = Regex.Match(memberName, "\\(([\\.,A-z0-9])*\\)").Groups[1].Captures.Join();
foreach (var paramtype in paramtypes.Split(','))
{
Type typ = null;
if (!TryFindType(paramtype, out typ))
{
var paramtype2 = Regex.Replace(paramtype, "(.*)\\.([A-z]*)$", "$1+$2");
TryFindType(paramtype2, out typ);
}
if (typ != null)
{
reflectedMethodParams.Add(typ);
}
}
if (!methodname.Contains('#'))
{
reflectedMethod = reflectedType.GetMethod(methodname, reflectedMethodParams.ToArray());
}
else
{
reflectedMethod = reflectedType.GetConstructor(reflectedMethodParams.ToArray());
}
// the method's name for constructors is #ctor, lets change that to the name of the Type
if (memberName.Contains("#ctor"))
{
CurrentDoc = new ConstructorDoc(CurrentType as TypeDoc);
CurrentDoc.Name = memberName.Replace("#ctor", Regex.Match(memberName, ".([A-z]+).#").Groups[1].Value).Substring(2);
CurrentDoc.Name = CurrentDoc.Name.Substring(0, CurrentDoc.Name.IndexOf("("));
}
else
{
CurrentDoc = new MethodDoc(CurrentType as TypeDoc);
}
CurrentMethod = CurrentDoc;
currentParam = 0;
if (reflectedMethod is MethodInfo)
{
CurrentMethod["ReturnType"] = (reflectedMethod as MethodInfo).ReturnType;
}
else
{
CurrentMethod["ReturnType"] = reflectedType;
}
break;
}
if (CurrentDoc.Name == null)
{
if (memberName.Contains("("))
{
CurrentDoc.Name = memberName.Substring(2, memberName.IndexOf("(") - 2);
}
else
{
CurrentDoc.Name = memberName.Substring(2);
}
}
break;
case "summary":
xml.Read();
if (PreviousDoc != null)
{
PreviousDoc["Summary"] = xml.Value.Trim();
}
break;
case "param":
string name = xml["name"];
xml.Read();
CurrentDoc = new ParameterDoc(CurrentMethod)
{
Name = name,
Summary = xml.Value,
Type = reflectedMethodParams[currentParam]
};
currentParam++;
break;
case "csharp":
case "javascript":
case "python":
case "lua":
if (PreviousDoc is TypeDoc)
{
var cdoc = PreviousDoc as TypeDoc;
var lang = xml.Name;
xml.Read();
cdoc.CodeExamples.Add(new CodeExample {
Code = xml.Value,
Language = (Language)Enum.Parse(typeof(Language), lang)
});
}
else if (PreviousDoc is MethodDoc)
{
var cdoc = PreviousDoc as MethodDoc;
var lang = xml.Name;
xml.Read();
cdoc.CodeExamples.Add(new CodeExample {
Code = xml.Value,
Language = (Language)Enum.Parse(typeof(Language), lang)
});
}
break;
case "value":
xml.Read();
PreviousDoc["defaultValue"] = xml.Value;
break;
}
if (CurrentDoc != null)
{
PreviousDoc = CurrentDoc;
}
}
}
}
#if DEBUG
Console.WriteLine("CurrentAssembly is: " + Environment.NewLine + CurrentAssembly);
#endif
CurrentAssembly.ToFile();
}
}
}
} catch (Exception ex) {
Console.WriteLine(ex.ToString());
Console.WriteLine(ex.StackTrace);
}
}
public static TypeDom Build(TypeDoc doc, AssemblyDom asm, Func<MemberDom, bool> filterMembers)
{
var ret = new TypeDom
{
Assembly = asm,
DocInfo = doc.DocInfo,
Type = doc.ReflectionType,
};
MemberDom[] members = doc.Members
.Where(_ => _.ReflectionMemberInfo != null)
.Select(_ => MemberDom.Build(ret, _.ReflectionMemberInfo, _.DocInfo))
.ToArray();
members = members.Where(
_ => (filterMembers==null || filterMembers(_)) && !_.IsPrivateOrInternal
).ToArray();
ret.AllMembers = members;
ret.Constructors = members.OfType<ConstructorDom>().OrderBy(_ => _.ShortSignature).ToArray();
ret.Fields = members.OfType<FieldDom>()
.OrderBy(_ => _.ShortSignature)
.ToArray();
ret.Properties = members.OfType<PropertyDom>()
.OrderBy(_ => _.ShortSignature)
.ToArray();
ret.Methods = members.OfType<MethodDom>()
.Where(_ => !_.IsOperator)
.OrderBy(_ => _.ShortSignature)
.ToArray();
ret.Operators = members.OfType<MethodDom>()
.Where(_ => _.IsOperator)
.OrderBy(_ => _.ShortSignature)
.ToArray();
ret.Events = members.OfType<EventDom>()
.OrderBy(_ => _.ShortSignature)
.ToArray();
ret.GenericTypeParameters = GenericParameterDom.BuildTypeGenericParameters(ret.Type, ret.DocInfo);
return ret;
}
public void FillInfo(TypeDoc info, IEnumerable <XElement> values, ContentType contentType)
{
GetSummaryAndRemarks(info, values, contentType);
}
public MethodDoc(TypeDoc parent, XElement element)
: this()
{
Parent = parent;
var attribute = element.Attribute("name")?.Value ?? string.Empty;
FullName = attribute.Replace("M:", string.Empty);
var firstParenthesis = attribute.IndexOf('(');
if (firstParenthesis < 0)
{
firstParenthesis = attribute.Length - 1;
}
var lastDot = attribute.LastIndexOf('.', firstParenthesis);
Name = attribute.Substring(lastDot + 1, firstParenthesis - lastDot - 1);
FullyQuantifiedName = attribute.Substring(0, firstParenthesis).Replace("M:", string.Empty);
IsConstructor = Name.StartsWith("#");
var xmlSummary = element.Descendants("summary").FirstOrDefault();
if (xmlSummary != null)
{
Summary = xmlSummary.Value;
}
var xmlRemarks = element.Descendants("remarks").FirstOrDefault();
if (xmlRemarks != null)
{
Remarks = xmlRemarks.Value;
}
var xmlExample = element.Descendants("example").FirstOrDefault();
if (xmlExample != null)
{
Example = xmlExample.Value;
}
var xmlPermission = element.Descendants("permission").FirstOrDefault();
if (xmlPermission != null)
{
Permission = xmlPermission.Value;
}
var xmlReturns = element.Descendants("returns").FirstOrDefault();
if (xmlReturns != null)
{
Returns = xmlReturns.Value;
}
//foreach (var seealso in element.Descendants("seealso"))
//{
// var crefAttribute = seealso.Attribute("cref");
// if (crefAttribute != null)
// {
// this.SeeAlso.Add(crefAttribute.Value.Contains("Proxy") ? DocumentationHelper.ApiProxyInstance.GetTypeDocumentation(crefAttribute.Value) : DocumentationHelper.InterfaceInstance.GetTypeDocumentation(crefAttribute.Value));
// }
//}
//foreach (var seealso in element.Descendants("see"))
//{
// var crefAttribute = seealso.Attribute("cref");
// if (crefAttribute != null)
// {
// this.SeeAlso.Add(crefAttribute.Value.Contains("Proxy") ? DocumentationHelper.ApiProxyInstance.GetTypeDocumentation(crefAttribute.Value) : DocumentationHelper.InterfaceInstance.GetTypeDocumentation(crefAttribute.Value));
// }
//}
firstParenthesis = FullName.IndexOf('(');
var parameterTypeList = firstParenthesis > 0
? FullName.Substring(
firstParenthesis + 1,
FullName.LastIndexOf(")", StringComparison.Ordinal) - firstParenthesis - 1).Split(',')
: new string[] { };
var parameterIndex = 0;
foreach (var param in element.Descendants("param"))
{
var nameAttribute = param.Attribute("name");
if (nameAttribute != null)
{
Params.Add(new MethodParam(nameAttribute.Value, param.Value, parameterTypeList[parameterIndex]));
}
parameterIndex++;
}
foreach (var exc in element.Descendants("exception"))
{
var crefAttribute = exc.Attribute("cref");
if (crefAttribute != null)
{
Exceptions.Add(new MethodException(crefAttribute.Value, exc.Value));
}
}
}
public DataTable LoadWaresDocs(TypeDoc parTypeDoc, int parNumberDoc)
{
//CurNumDoc = parNumberDoc;
SetCurDoc(parNumberDoc);
return(dtWaresDoc = cData.FillDocsWares(parNumberDoc));
}
public DataTable LoadDocs(TypeDoc parTypeDoc)
{
CurTypeDoc = parTypeDoc;
return(dtDocs = cData.FillDocs(parTypeDoc));
}
public void FillInfo(TypeDoc info, IEnumerable<XElement> values, ContentType contentType)
{
GetSummaryAndRemarks(info, values, contentType);
}
