public void Convert_Type_WhenHasNoNameAndNamespace_ReturnsEmptyString()
{
TypeDef type = CreateTypeDef(string.Empty, string.Empty);
var convertor = new DisplayNameSignitureConvertor(type, false);
string result = convertor.Convert();
Assert.AreEqual(string.Empty, result);
}
public override void Render(System.Xml.XmlWriter writer)
{
writer.WriteStartDocument();
writer.WriteStartElement("members");
writer.WriteAttributeString("id", this.AssociatedEntry.Key.ToString());
writer.WriteAttributeString("subId", this.AssociatedEntry.SubKey);
WriteCref(this.AssociatedEntry, writer);
string typeDisplayName = _containingType.GetDisplayName(false);
string pageDisplayName = $"{typeDisplayName} {this.AssociatedEntry.Name}";
writer.WriteStartElement("name");
writer.WriteAttributeString("safename", Exporter.CreateSafeName(pageDisplayName));
writer.WriteAttributeString("type", typeDisplayName);
writer.WriteString(pageDisplayName);
writer.WriteEndElement();
// we need to write the entries that appear as children to this document map
// entry. it is going to be easier to use the Entry elements
writer.WriteStartElement("entries");
switch (AssociatedEntry.SubKey.ToLower())
{
case "properties":
case "fields":
case "constants":
case "operators":
case "constructors":
foreach (Entry current in AssociatedEntry.Children)
{
ReflectedMember m = current.Item as ReflectedMember;
this.WriteEntry(writer, m, ReflectionHelper.GetDisplayName(m));
}
break;
case "methods":
// write normal methods
foreach (Entry current in AssociatedEntry.Children)
{
ReflectedMember m = current.Item as ReflectedMember;
WriteEntry(writer, m, ReflectionHelper.GetDisplayName(m));
}
// write extension methods
var extensionMethods = from method in ((TypeRef)AssociatedEntry.Parent.Item).ExtensionMethods
orderby method.Name
select method;
foreach (MethodDef currentMethod in extensionMethods)
{
DisplayNameSignitureConvertor displayNameSig = new DisplayNameSignitureConvertor(currentMethod, false, true, true);
WriteEntry(writer, currentMethod, currentMethod.GetDisplayName(false, true), "extensionmethod");
}
break;
}
writer.WriteEndElement(); // entries
writer.WriteEndElement();
writer.WriteEndDocument();
}
public void Convert_Type_WhenHasNameAndNamespace_ReturnsCorrectly()
{
TypeDef type = CreateTypeDef("MyName", "Reflection");
var convertor = new DisplayNameSignitureConvertor(type, true);
string result = convertor.Convert();
Assert.AreEqual("Reflection.MyName", result);
}
public void Convert_Type_WhenHasNameAndNoNamespaceButIncludeNamespaceSet_ReturnsCorrectly()
{
TypeDef type = CreateTypeDef("MyName", string.Empty);
var convertor = new DisplayNameSignitureConvertor(type, true);
string result = convertor.Convert();
Assert.AreEqual("MyName", result);
}
public void Convert_MethodDef_WhenNoNamespaceAndParametersSelected_ShouldOnlyReturnName()
{
MethodDef method = CreateMethod();
var convertor = new DisplayNameSignitureConvertor(method, false, false);
string result = convertor.Convert();
Assert.AreEqual("MyMethod", result);
}
public void Convert_MethodDef_WhenNamespaceSelectedButNoParameters_ShouldReturnNameAndNamespace()
{
MethodDef method = CreateMethod();
var convertor = new DisplayNameSignitureConvertor(method, true, false);
string result = convertor.Convert();
// include namespace does absolutely nothing when using methods
Assert.AreEqual("MyMethod", result);
}
public void Convert_MethodDef_WhenNoParametersAndParametersIncluded_ShouldShowEmptyParaemterList()
{
MethodDef method = CreateMethod();
var convertor = new DisplayNameSignitureConvertor(method, true, true);
// we need a signiture for this to work which means we need to load the pecoffile
string result = convertor.Convert();
Assert.AreEqual("MyMethod()", result);
}
// [Test] - cant do this yet as we need Signatures to be loaded, we first need to somehow
// mock out the Signatures so we can control the return information.
public void Convert_MethodDef_WhenParametersAndParametersIncluded_ShouldShowParameters()
{
MethodDef method = CreateMethod();
ParamDef parameter = new ParamDef();
parameter.Name = "test";
method.Parameters.Add(parameter);
parameter.Method = method;
var convertor = new DisplayNameSignitureConvertor(method, true, true);
string result = convertor.Convert();
Assert.AreEqual(string.Empty, result);
}
/// <summary>
/// Initialises a new instance of the SearchResult class.
/// </summary>
/// <param name="relatedEntry">The entry related to this result</param>
public SearchResult(Entry relatedEntry)
{
this.RelatedEntry = relatedEntry;
_member = null;
if (this.RelatedEntry.Item is List <ReflectedMember> )
{
// ignore these are list entries e.g. Properties
}
else if (this.RelatedEntry.Item is KeyValuePair <string, List <TypeDef> > )
{
// namespace
}
else
{
_member = (ReflectedMember)this.RelatedEntry.Item;
}
if (_member != null)
{
if (_member is PropertyDef)
{
PropertyDef property = _member as PropertyDef;
string propertyName = new DisplayNameSignitureConvertor(property, false, true).Convert();
Name = propertyName + " in " + property.OwningType.GetDisplayName(false);
}
else if (_member is TypeDef)
{
this.Name = ((TypeDef)_member).GetDisplayName(false);
}
else if (_member is MethodDef)
{
this.Name = string.Format("{1} in {0}", ((MethodDef)_member).Type.GetDisplayName(false), ((MethodDef)_member).GetDisplayName(false, true));
}
}
if (string.IsNullOrEmpty(this.Name))
{
this.Name = this.RelatedEntry.Name;
}
}
public void Convert_PropertyDef_WhenPropertyHasNoParameters_ShouldReturnTheName()
{
PropertyDef property = new PropertyDef();
property.Name = "MyProperty";
MethodDef getter = new MethodDef();
getter.Name = "get_MyProperty";
property.Getter = getter;
TypeDef container = new TypeDef();
container.Properties.Add(property);
property.OwningType = container;
var convertor = new DisplayNameSignitureConvertor(property, false, false);
string result = convertor.Convert();
Assert.AreEqual("MyProperty", result);
}
/// <summary>
/// Returns a nice display name for the type
/// </summary>
/// <param name="includeNamespace">
/// Indicates wether or not the namespace should be included.
/// </param>
/// <returns>A string that is a nice representation of the type for display purposes.</returns>
/// <remarks>
/// This method will return a name that can be used to display to users of
/// applications utilising this type.
/// <example>
/// Generic Type: List<MyClass>
/// Array: MyClass[]
/// Normal: MyClass
/// </example>
/// </remarks>
public virtual string GetDisplayName(bool includeNamespace)
{
string name = string.Empty;
if (this is TypeDef)
{
DisplayNameSignitureConvertor convertor = new DisplayNameSignitureConvertor((TypeDef)this, includeNamespace);
return(convertor.Convert());
}
else
{
if (includeNamespace)
{
name = this.GetFullyQualifiedName();
}
else
{
name = this.Name;
}
if (this.IsGeneric)
{
if (this is TypeSpec)
{
TypeRef def = ((TypeSpec)this).TypeDetails.Type;
name = def.GetDisplayName(includeNamespace);
}
else
{
int count = int.Parse(name.Substring(name.IndexOf('`') + 1));
name = name.Substring(0, name.IndexOf('`'));
name += "<" + new String(',', count - 1) + ">";
}
}
}
return(name);
}
/// <summary>
/// Obtains a name to display for the reflected member.
/// </summary>
/// <param name="entry">The entry.</param>
/// <returns>A name for the ReflectedMember</returns>
public static string GetDisplayName(ReflectedMember entry)
{
string displayName = string.Empty;
if (entry is FieldDef)
{
displayName = ((FieldDef)entry).Name;
}
else if (entry is PropertyDef)
{
PropertyDef property = entry as PropertyDef;
displayName = new DisplayNameSignitureConvertor(property, false, true).Convert();
}
else if (entry is MethodDef)
{
displayName = ((MethodDef)entry).GetDisplayName(false, true);
}
else if (entry is EventDef)
{
displayName = ((EventDef)entry).Name;
}
return(displayName);
}
public void DisplayNameOfGenericMethodReturnInLibrary()
{
DisplayNameSignitureConvertor convertor = new DisplayNameSignitureConvertor(_method2, true, true);
convertor.Convert();
}
public void DisplayNameOfGenericMethodReturnWellKnownType()
{
DisplayNameSignitureConvertor convertor = new DisplayNameSignitureConvertor(_method1, true, true);
convertor.Convert();
}
private void OutputMembers(System.Xml.XmlWriter writer)
{
if (this.AssociatedEntry.Children.Count == 0)
{
return;
}
writer.WriteStartElement("entries");
List <Entry> children = AssociatedEntry.Children;
Entry constructors = children.Find(entry => entry.Name == "Constructors");
if (constructors != null)
{
var s = from child in constructors.Children orderby child.Name select child;
foreach (Entry current in s)
{
MethodDef currentMember = (MethodDef)current.Item;
WriteEntry(writer, currentMember, currentMember.GetDisplayName(false, true));
}
}
Entry fields = children.Find(entry => entry.Name == "Fields");
if (fields != null)
{
var s = from child in fields.Children orderby child.Name select child;
foreach (Entry current in s)
{
FieldDef currentMember = (FieldDef)current.Item;
WriteEntry(writer, currentMember, currentMember.Name);
}
}
Entry properties = children.Find(entry => entry.Name == "Properties");
if (properties != null)
{
var s = from child in properties.Children orderby child.Name select child;
foreach (Entry current in s)
{
PropertyDef currentMember = current.Item as PropertyDef;
WriteEntry(writer, currentMember, new DisplayNameSignitureConvertor(currentMember, false, true).Convert());
}
}
Entry events = children.Find(entry => entry.Name == "Events");
if (events != null)
{
var s = from child in events.Children orderby child.Name select child;
foreach (Entry current in s)
{
EventDef currentMember = (EventDef)current.Item;
WriteEntry(writer, currentMember, currentMember.Name);
}
}
Entry methods = children.Find(entry => entry.Name == "Methods");
if (methods != null)
{
var s = from child in methods.Children orderby child.Name select child;
foreach (Entry current in s)
{
MethodDef currentMember = (MethodDef)current.Item;
WriteEntry(writer, currentMember, currentMember.GetDisplayName(false, true));
}
}
Entry operators = children.Find(entry => entry.Name == "Operators");
if (operators != null)
{
var s = from child in operators.Children orderby child.Name select child;
foreach (Entry current in s)
{
MethodDef currentMember = (MethodDef)current.Item;
WriteEntry(writer, currentMember, currentMember.GetDisplayName(false));
}
}
// I dont think we have any extension methods anymore - perhaps we can just delete this code?
var extensionMethods = from method in this._member.ExtensionMethods orderby method.Name select method;
foreach (MethodDef currentMethod in extensionMethods)
{
DisplayNameSignitureConvertor displayNameSig = new DisplayNameSignitureConvertor(currentMethod, false, true, true);
WriteEntry(writer, currentMethod, currentMethod.GetDisplayName(false, true), "extensionmethod");
}
writer.WriteEndElement();
}
public override void Render(System.Xml.XmlWriter writer)
{
CRefPath crefPath = new CRefPath(_member);
XmlCodeComment comment = _xmlComments.GetComment(crefPath);
string displayName = new DisplayNameSignitureConvertor(_member, false, true).Convert();
writer.WriteStartElement("member");
writer.WriteAttributeString("id", AssociatedEntry.Key.ToString());
writer.WriteAttributeString("subId", AssociatedEntry.SubKey);
writer.WriteAttributeString("type", ReflectionHelper.GetType(_member));
WriteCref(AssociatedEntry, writer);
writer.WriteStartElement("name");
writer.WriteAttributeString("safename", displayName);
writer.WriteString(displayName);
writer.WriteEndElement();
writer.WriteStartElement("namespace");
Entry namespaceEntry = AssociatedEntry.FindNamespace(_member.OwningType.Namespace);
writer.WriteAttributeString("id", namespaceEntry.Key.ToString());
writer.WriteAttributeString("name", namespaceEntry.SubKey);
writer.WriteAttributeString("cref", $"N:{_member.OwningType.Namespace}");
writer.WriteString(_member.OwningType.Namespace);
writer.WriteEndElement();
writer.WriteStartElement("assembly");
writer.WriteAttributeString("file", System.IO.Path.GetFileName(_member.Assembly.FileName));
writer.WriteString(_member.Assembly.Name);
writer.WriteEndElement();
// find and output the summary
if (comment != XmlCodeComment.Empty)
{
XmlCodeElement summary = comment.Elements.Find(currentBlock => currentBlock is SummaryXmlCodeElement);
if (summary != null)
{
Serialize(summary, writer);
}
}
RenderExceptionBlock(_member, writer, comment);
RenderPermissionBlock(_member, writer, comment);
RenderSyntaxBlocks(_member, writer);
MethodDef internalMethod = _member.Getter == null ? _member.Setter : _member.Getter;
if (_member.IsIndexer() && internalMethod.Parameters.Count > 0)
{
writer.WriteStartElement("parameters");
for (int i = 0; i < internalMethod.Parameters.Count; i++)
{
if (internalMethod.Parameters[i].Sequence == 0)
{
continue;
}
TypeRef parameterType = internalMethod.ResolveParameter(internalMethod.Parameters[i].Sequence);
TypeDef foundEntry = _member.Assembly.FindType(parameterType.Namespace, parameterType.Name);
writer.WriteStartElement("parameter");
writer.WriteAttributeString("name", internalMethod.Parameters[i].Name);
writer.WriteStartElement("type");
if (foundEntry != null)
{
writer.WriteAttributeString("key", foundEntry.GetGloballyUniqueId().ToString());
writer.WriteAttributeString("cref", CRefPath.Create(foundEntry).ToString());
}
writer.WriteString(parameterType.GetDisplayName(false));
writer.WriteEndElement(); // type
if (comment != XmlCodeComment.Empty)
{
XmlCodeElement paramEntry = comment.Elements.Find(currentBlock =>
currentBlock is ParamXmlCodeElement &&
((ParamXmlCodeElement)currentBlock).Name == internalMethod.Parameters[i].Name);
if (paramEntry != null)
{
writer.WriteStartElement("description");
ParamXmlCodeElement paraElement = (ParamXmlCodeElement)paramEntry;
for (int j = 0; j < paraElement.Elements.Count; j++)
{
Serialize(paraElement.Elements[j], writer);
}
writer.WriteEndElement();
}
}
writer.WriteEndElement(); // parameter
}
writer.WriteEndElement();
}
// find and output the value
if (comment != XmlCodeComment.Empty)
{
XmlCodeElement remarks = comment.Elements.Find(currentBlock => currentBlock is ValueXmlCodeElement);
if (remarks != null)
{
Serialize(remarks, writer);
}
}
// find and output the remarks
if (comment != XmlCodeComment.Empty)
{
XmlCodeElement remarks = comment.Elements.Find(currentBlock => currentBlock is RemarksXmlCodeElement);
if (remarks != null)
{
Serialize(remarks, writer);
}
}
// find and output the examples
if (comment != XmlCodeComment.Empty)
{
XmlCodeElement remarks = comment.Elements.Find(currentBlock => currentBlock is ExampleXmlCodeElement);
if (remarks != null)
{
Serialize(remarks, writer);
}
}
RenderSeeAlsoBlock(_member, writer, comment);
writer.WriteEndElement();
}
public override void Generate()
{
if (!this.IsGenerated)
{
CRefPath crefPath = null;
SummaryTable members;
if (!this.xmlComments.Exists())
{
this.Blocks.Add(new NoXmlComments(this.representedType));
}
this.Blocks.Add(new Header1(this.representedType.GetDisplayName(false) + " Members"));
List <MethodDef> constructors = this.representedType.GetConstructors();
if (constructors != null && constructors.Count > 0)
{
this.Blocks.Add(new Header2("Constructors"));
members = new SummaryTable();
var sortedMethods = from method in constructors
orderby method.Name
where !LiveDocumentorFile.Singleton.LiveDocument.IsMemberFiltered(method)
select method;
foreach (MethodDef currentMethod in sortedMethods)
{
crefPath = new CRefPath(currentMethod);
System.Windows.Documents.Hyperlink link = new System.Windows.Documents.Hyperlink();
link.Inlines.Add(new System.Windows.Documents.Run(currentMethod.GetDisplayName(false)));
link.Tag = new EntryKey(currentMethod.GetGloballyUniqueId());
link.Click += new System.Windows.RoutedEventHandler(LinkHelper.Resolve);
Block description = this.GetSummaryFor(xmlComments,
currentMethod.Assembly,
crefPath);
members.AddItem(link, description, Model.ElementIconConstants.GetIconPathFor(currentMethod));
}
this.Blocks.Add(members);
}
List <FieldDef> fields = this.representedType.GetFields();
if (fields != null && fields.Count > 0)
{
this.Blocks.Add(new Header2("Fields"));
members = new SummaryTable();
var sortedFields = from field in fields
orderby field.Name
where !LiveDocumentorFile.Singleton.LiveDocument.IsMemberFiltered(field)
select field;
foreach (FieldDef currentField in sortedFields)
{
crefPath = new CRefPath(currentField);
System.Windows.Documents.Hyperlink link = new System.Windows.Documents.Hyperlink();
link.Inlines.Add(new System.Windows.Documents.Run(currentField.Name));
link.Tag = new EntryKey(currentField.GetGloballyUniqueId());
link.Click += new System.Windows.RoutedEventHandler(LinkHelper.Resolve);
Block description = this.GetSummaryFor(xmlComments,
currentField.Assembly,
crefPath);
Block value = this.GetSummaryFor(xmlComments,
currentField.Assembly,
crefPath);
if (description != null)
{
members.AddItem(link, description, Model.ElementIconConstants.GetIconPathFor(currentField));
}
else
{
members.AddItem(link, value, Model.ElementIconConstants.GetIconPathFor(currentField));
}
}
this.Blocks.Add(members);
}
List <PropertyDef> properties = this.representedType.GetProperties();
if (properties != null && properties.Count > 0)
{
this.Blocks.Add(new Header2("Properties"));
members = new SummaryTable();
var sortedProperties = from property in properties
orderby new DisplayNameSignitureConvertor(property, false, true).Convert()
where !LiveDocumentorFile.Singleton.LiveDocument.IsMemberFiltered(property)
select property;
foreach (PropertyDef currentProperty in sortedProperties)
{
crefPath = new CRefPath(currentProperty);
System.Windows.Documents.Hyperlink link = new System.Windows.Documents.Hyperlink();
link.Inlines.Add(new Run(new DisplayNameSignitureConvertor(currentProperty, false, true).Convert()));
link.Tag = new EntryKey(currentProperty.GetGloballyUniqueId());
link.Click += new System.Windows.RoutedEventHandler(LinkHelper.Resolve);
Block description = this.GetSummaryFor(xmlComments, currentProperty.OwningType.Assembly, crefPath);
members.AddItem(link, description, Model.ElementIconConstants.GetIconPathFor(currentProperty));
}
this.Blocks.Add(members);
}
List <EventDef> events = this.representedType.GetEvents();
if (events != null && events.Count > 0)
{
this.Blocks.Add(new Header2("Events"));
members = new SummaryTable();
var sortedEvents = from c in events
orderby c.Name
where !LiveDocumentorFile.Singleton.LiveDocument.IsMemberFiltered(c)
select c;
foreach (EventDef currentEvent in sortedEvents)
{
crefPath = new CRefPath(currentEvent);
System.Windows.Documents.Hyperlink link = new System.Windows.Documents.Hyperlink();
link.Inlines.Add(new System.Windows.Documents.Run(currentEvent.Name));
link.Tag = new EntryKey(currentEvent.GetGloballyUniqueId());
link.Click += new System.Windows.RoutedEventHandler(LinkHelper.Resolve);
Block description = this.GetSummaryFor(xmlComments, currentEvent.Type.Assembly,
crefPath);
members.AddItem(link, description, Model.ElementIconConstants.GetIconPathFor(currentEvent));
}
this.Blocks.Add(members);
}
List <MethodDef> methods = this.representedType.GetMethods();
if (methods != null && methods.Count > 0)
{
this.Blocks.Add(new Header2("Methods"));
members = new SummaryTable();
var sortedMethods = from method in methods
orderby method.Name
where !LiveDocumentorFile.Singleton.LiveDocument.IsMemberFiltered(method)
select method;
foreach (MethodDef currentMethod in sortedMethods)
{
crefPath = new CRefPath(currentMethod);
System.Windows.Documents.Hyperlink link = new System.Windows.Documents.Hyperlink();
link.Inlines.Add(new System.Windows.Documents.Run(currentMethod.GetDisplayName(false)));
link.Tag = new EntryKey(currentMethod.GetGloballyUniqueId());
link.Click += new System.Windows.RoutedEventHandler(LinkHelper.Resolve);
Block description = this.GetSummaryFor(xmlComments, currentMethod.Assembly,
crefPath);
members.AddItem(link, description, Model.ElementIconConstants.GetIconPathFor(currentMethod));
}
this.Blocks.Add(members);
}
List <MethodDef> operators = this.representedType.GetOperators();
if (operators != null && operators.Count > 0)
{
this.Blocks.Add(new Header2("Operators"));
members = new SummaryTable();
var sortedMethods = from method in operators
orderby method.Name
where !LiveDocumentorFile.Singleton.LiveDocument.IsMemberFiltered(method)
select method;
foreach (MethodDef currentMethod in sortedMethods)
{
crefPath = new CRefPath(currentMethod);
System.Windows.Documents.Hyperlink link = new System.Windows.Documents.Hyperlink();
link.Inlines.Add(new System.Windows.Documents.Run(currentMethod.GetDisplayName(false)));
link.Tag = new EntryKey(currentMethod.GetGloballyUniqueId());
link.Click += new System.Windows.RoutedEventHandler(LinkHelper.Resolve);
Block description = this.GetSummaryFor(xmlComments, currentMethod.Assembly,
crefPath);
members.AddItem(link, description, Model.ElementIconConstants.GetIconPathFor(currentMethod));
}
this.Blocks.Add(members);
}
if (this.representedType != null && this.representedType.ExtensionMethods.Count > 0)
{
members = new SummaryTable();
var sortedMethods = from method in this.representedType.ExtensionMethods
where !method.IsConstructor
orderby method.Name
where !LiveDocumentorFile.Singleton.LiveDocument.IsMemberFiltered(method)
select method;
foreach (MethodDef currentMethod in sortedMethods)
{
DisplayNameSignitureConvertor displayNameSig = new DisplayNameSignitureConvertor(currentMethod, false, true, true);
System.Windows.Documents.Hyperlink link = new System.Windows.Documents.Hyperlink();
link.Inlines.Add(new System.Windows.Documents.Run(displayNameSig.Convert()));
link.Tag = new EntryKey(currentMethod.GetGloballyUniqueId());
link.Click += new System.Windows.RoutedEventHandler(LinkHelper.Resolve);
CRefPath path = new CRefPath(currentMethod);
Block description = this.GetSummaryFor(xmlComments,
currentMethod.Assembly,
path
);
members.AddItem(link, description, Model.ElementIconConstants.GetIconPathFor(currentMethod));
}
this.Blocks.Add(new Header2("Extension Methods"));
this.Blocks.Add(members);
}
this.IsGenerated = true;
}
}
/// <summary>
/// Outputs the members tables.
/// </summary>
private void OutputMembersLists()
{
SummaryTable members;
CRefPath crefPath;
List <Block> tempContainer = new List <Block>();
var constructors = from method in this._representedType.GetConstructors()
orderby method.Name
where !LiveDocumentorFile.Singleton.LiveDocument.IsMemberFiltered(method)
select method;
if (constructors != null && constructors.Count() > 0)
{
tempContainer.Add(new Header2("Constructors"));
members = new SummaryTable();
foreach (MethodDef currentMethod in constructors)
{
crefPath = new CRefPath(currentMethod);
System.Windows.Documents.Hyperlink link = new System.Windows.Documents.Hyperlink();
link.Inlines.Add(new System.Windows.Documents.Run(currentMethod.GetDisplayName(false)));
link.Tag = new EntryKey(currentMethod.GetGloballyUniqueId());
link.Click += new System.Windows.RoutedEventHandler(LinkHelper.Resolve);
Block description = this.GetSummaryFor(_commentsXml,
currentMethod.Assembly,
crefPath);
members.AddItem(link, description, Model.ElementIconConstants.GetIconPathFor(currentMethod));
}
tempContainer.Add(members);
}
var fields = from field in this._representedType.GetFields()
orderby field.Name
where !LiveDocumentorFile.Singleton.LiveDocument.IsMemberFiltered(field)
select field;
if (fields != null && fields.Count() > 0)
{
tempContainer.Add(new Header2("Fields"));
members = new SummaryTable();
foreach (FieldDef currentField in fields)
{
crefPath = new CRefPath(currentField);
System.Windows.Documents.Hyperlink link = new System.Windows.Documents.Hyperlink();
link.Inlines.Add(new System.Windows.Documents.Run(currentField.Name));
link.Tag = new EntryKey(currentField.GetGloballyUniqueId());
link.Click += new System.Windows.RoutedEventHandler(LinkHelper.Resolve);
Block description = this.GetSummaryFor(_commentsXml,
currentField.Assembly,
crefPath);
Block value = this.GetSummaryFor(_commentsXml,
currentField.Assembly,
crefPath);
if (description != null)
{
members.AddItem(link, description, Model.ElementIconConstants.GetIconPathFor(currentField));
}
else
{
members.AddItem(link, value, Model.ElementIconConstants.GetIconPathFor(currentField));
}
}
tempContainer.Add(members);
}
var properties = from property in this._representedType.GetProperties()
orderby new DisplayNameSignitureConvertor(property, false, true).Convert()
where !LiveDocumentorFile.Singleton.LiveDocument.IsMemberFiltered(property)
select property;
if (properties != null && properties.Count() > 0)
{
tempContainer.Add(new Header2("Properties"));
members = new SummaryTable();
foreach (PropertyDef currentProperty in properties)
{
crefPath = new CRefPath(currentProperty);
System.Windows.Documents.Hyperlink link = new System.Windows.Documents.Hyperlink();
link.Inlines.Add(new Run(new DisplayNameSignitureConvertor(currentProperty, false, true).Convert()));
link.Tag = new EntryKey(currentProperty.GetGloballyUniqueId());
link.Click += new System.Windows.RoutedEventHandler(LinkHelper.Resolve);
Block description = this.GetSummaryFor(_commentsXml, currentProperty.OwningType.Assembly,
crefPath);
members.AddItem(link, description, Model.ElementIconConstants.GetIconPathFor(currentProperty));
}
tempContainer.Add(members);
}
var events = from c in this._representedType.GetEvents()
orderby c.Name
where !LiveDocumentorFile.Singleton.LiveDocument.IsMemberFiltered(c)
select c;
if (events != null && events.Count() > 0)
{
tempContainer.Add(new Header2("Events"));
members = new SummaryTable();
foreach (EventDef currentEvent in events)
{
crefPath = new CRefPath(currentEvent);
System.Windows.Documents.Hyperlink link = new System.Windows.Documents.Hyperlink();
link.Inlines.Add(new System.Windows.Documents.Run(currentEvent.Name));
link.Tag = new EntryKey(currentEvent.GetGloballyUniqueId());
link.Click += new System.Windows.RoutedEventHandler(LinkHelper.Resolve);
Block description = this.GetSummaryFor(_commentsXml, currentEvent.Type.Assembly,
crefPath);
members.AddItem(link, description, Model.ElementIconConstants.GetIconPathFor(currentEvent));
}
tempContainer.Add(members);
}
var methods = from method in this._representedType.GetMethods()
orderby method.Name
where !LiveDocumentorFile.Singleton.LiveDocument.IsMemberFiltered(method)
select method;
if (methods != null && methods.Count() > 0)
{
tempContainer.Add(new Header2("Methods"));
members = new SummaryTable();
foreach (MethodDef currentMethod in methods)
{
crefPath = new CRefPath(currentMethod);
System.Windows.Documents.Hyperlink link = new System.Windows.Documents.Hyperlink();
link.Inlines.Add(new System.Windows.Documents.Run(currentMethod.GetDisplayName(false)));
link.Tag = new EntryKey(currentMethod.GetGloballyUniqueId());
link.Click += new System.Windows.RoutedEventHandler(LinkHelper.Resolve);
Block description = this.GetSummaryFor(_commentsXml, currentMethod.Assembly,
crefPath);
members.AddItem(link, description, Model.ElementIconConstants.GetIconPathFor(currentMethod));
}
tempContainer.Add(members);
}
var operators = from method in this._representedType.GetOperators()
orderby method.Name
where !LiveDocumentorFile.Singleton.LiveDocument.IsMemberFiltered(method)
select method;
if (operators != null && operators.Count() > 0)
{
tempContainer.Add(new Header2("Operators"));
members = new SummaryTable();
foreach (MethodDef currentMethod in operators)
{
crefPath = new CRefPath(currentMethod);
System.Windows.Documents.Hyperlink link = new System.Windows.Documents.Hyperlink();
link.Inlines.Add(new System.Windows.Documents.Run(currentMethod.GetDisplayName(false)));
link.Tag = new EntryKey(currentMethod.GetGloballyUniqueId());
link.Click += new System.Windows.RoutedEventHandler(LinkHelper.Resolve);
Block description = this.GetSummaryFor(_commentsXml, currentMethod.Assembly,
crefPath);
members.AddItem(link, description, Model.ElementIconConstants.GetIconPathFor(currentMethod));
}
tempContainer.Add(members);
}
if (this._representedType != null && this._representedType.ExtensionMethods.Count > 0)
{
members = new SummaryTable();
var sortedMethods = from method in this._representedType.ExtensionMethods
where !method.IsConstructor
orderby method.Name
where !LiveDocumentorFile.Singleton.LiveDocument.IsMemberFiltered(method)
select method;
foreach (MethodDef currentMethod in sortedMethods)
{
DisplayNameSignitureConvertor displayNameSig = new DisplayNameSignitureConvertor(currentMethod, false, true, true);
System.Windows.Documents.Hyperlink link = new System.Windows.Documents.Hyperlink();
link.Inlines.Add(new System.Windows.Documents.Run(displayNameSig.Convert()));
link.Tag = new EntryKey(currentMethod.GetGloballyUniqueId());
link.Click += new System.Windows.RoutedEventHandler(LinkHelper.Resolve);
CRefPath path = new CRefPath(currentMethod);
Block description = this.GetSummaryFor(_commentsXml,
currentMethod.Assembly,
path
);
members.AddItem(link, description, Model.ElementIconConstants.GetIconPathFor(currentMethod));
}
tempContainer.Add(new Header2("Extension Methods"));
tempContainer.Add(members);
}
if (tempContainer.Count > 0)
{
this.Blocks.Add(new Paragraph());
this.Blocks.Add(new Paragraph(new Run(string.Format("The {0} type exposes the following members.", this._representedType.GetDisplayName(false)))));
this.Blocks.AddRange(tempContainer);
}
}
public override void Generate()
{
if (!IsGenerated)
{
TypeDef definingType = null;
if (_typesMethods != null && _typesMethods.Count > 0)
{
definingType = _typesMethods[0].Type as TypeDef;
}
if (!_xmlComments.Exists())
{
Blocks.Add(new NoXmlComments(definingType));
}
Blocks.Add(new Header1(definingType.GetDisplayName(false) + " Methods"));
if (_typesMethods != null && _typesMethods.Count > 0)
{
SummaryTable methods = new SummaryTable();
var sortedMethods = from method in this._typesMethods
where !method.IsConstructor
orderby method.Name
where !LiveDocumentorFile.Singleton.LiveDocument.IsMemberFiltered(method)
select method;
foreach (MethodDef currentMethod in sortedMethods)
{
System.Windows.Documents.Hyperlink link = new System.Windows.Documents.Hyperlink();
link.Inlines.Add(new System.Windows.Documents.Run(currentMethod.GetDisplayName(false)));
link.Tag = new EntryKey(currentMethod.GetGloballyUniqueId());
link.Click += new System.Windows.RoutedEventHandler(LinkHelper.Resolve);
CRefPath path = new CRefPath(currentMethod);
System.Windows.Documents.Block description = this.GetSummaryFor(_xmlComments,
currentMethod.Assembly,
path
);
methods.AddItem(link, description, Model.ElementIconConstants.GetIconPathFor(currentMethod));
}
Blocks.Add(methods);
}
if (definingType != null && definingType.ExtensionMethods.Count > 0)
{
SummaryTable methods = new SummaryTable();
var sortedMethods = from method in definingType.ExtensionMethods
where !method.IsConstructor
orderby method.Name
where !LiveDocumentorFile.Singleton.LiveDocument.IsMemberFiltered(method)
select method;
foreach (MethodDef currentMethod in sortedMethods)
{
DisplayNameSignitureConvertor displayNameSig = new DisplayNameSignitureConvertor(currentMethod, false, true, true);
System.Windows.Documents.Hyperlink link = new System.Windows.Documents.Hyperlink();
link.Inlines.Add(new System.Windows.Documents.Run(displayNameSig.Convert()));
link.Tag = new EntryKey(currentMethod.GetGloballyUniqueId());
link.Click += new System.Windows.RoutedEventHandler(LinkHelper.Resolve);
CRefPath path = new CRefPath(currentMethod);
System.Windows.Documents.Block description = this.GetSummaryFor(_xmlComments,
currentMethod.Assembly,
path
);
methods.AddItem(link, description, Model.ElementIconConstants.GetIconPathFor(currentMethod));
}
Blocks.Add(new Header2("Extension Methods"));
Blocks.Add(methods);
}
IsGenerated = true;
// we also no longer need to store a reference to the XML file I think so we can remove it
_xmlComments = null;
_typesMethods = null;
}
}
/// <summary>
/// Obtains a display ready version of the method name.
/// </summary>
/// <param name="includeNamespace">Indicates if the namespace should be included, this will include the type name.</param>
/// <param name="includeParameters">Indicates if the parameters should be included.</param>
/// <returns>A string representing a display ready version of the MethodDef name.</returns>
public string GetDisplayName(bool includeNamespace, bool includeParameters)
{
DisplayNameSignitureConvertor convertor = new DisplayNameSignitureConvertor(this, includeNamespace, includeParameters);
return(convertor.Convert());
}
