private static void AppendParameters(DescriptionBuilder sb, NetBrowserManager manager, ParameterInfo[] parameters)
{
bool first = true;
foreach (ParameterInfo parameter in parameters)
{
if (first)
{
first = false;
}
else
{
sb.Append(", ");
}
if (parameter.IsOptional)
{
sb.Append("[");
}
NetTypeBrowserInfo.WriteParameterType(manager, sb, parameter, true);
sb.Append(" ");
sb.Append(parameter.Name);
if (parameter.IsOptional)
{
sb.Append("]");
}
}
}
private static int CompareTypeNames(Type a, Type b)
{
// Compare the names with case-insensitive comparison first (for ordering purposes)
string nameA = NetTypeBrowserInfo.GetTypeDisplayName(a);
string nameB = NetTypeBrowserInfo.GetTypeDisplayName(b);
int result = string.Compare(nameA, nameB, true);
if (result != 0)
{
return(result);
}
// Same - now do a case-sensitive comparison.
result = string.Compare(nameA, nameB, false);
if (result != 0)
{
return(result);
}
// Type names are exactly the same - compare assembly-qualified names.
return(string.Compare(a.AssemblyQualifiedName, b.AssemblyQualifiedName, false));
}
internal NetTypeBrowserInfo GetTypeInfo(Type type)
{
Debug.Assert(type != null, "type != null");
NetTypeBrowserInfo typeInfo = (NetTypeBrowserInfo)m_cachedTypes[type];
if (typeInfo == null)
{
NetAssemblyBrowserInfo assembly = GetAssemblyInfo(type.Assembly);
Debug.Assert(assembly != null, "assembly != null");
string nsName = (type.Namespace == null ? NetBrowserSettings.NullNamespaceName : type.Namespace);
NetNamespaceBrowserInfo ns = assembly.GetNamespace(nsName);
Debug.Assert(ns != null, "ns != null");
// Retrieving the namespaces may add types to CachedTypes, so try to find this type again.
typeInfo = (NetTypeBrowserInfo)m_cachedTypes[type];
if (typeInfo == null)
{
typeInfo = new NetTypeBrowserInfo(type, ns);
m_cachedTypes.Add(type, typeInfo);
}
}
return(typeInfo);
}
internal NetMemberBrowserInfo(NetTypeBrowserInfo type, MemberInfo memberInfo, string nodeText)
{
Debug.Assert(type != null && memberInfo != null && nodeText != null,
"type != null && memberInfo != null && nodeText != null");
m_type = type;
m_memberInfo = memberInfo;
m_nodeText = nodeText;
}
internal RemoteTypeBrowserInfo(NetTypeBrowserInfo wrapped, RemoteNamespaceBrowserInfo ns, string name)
{
Debug.Assert(wrapped != null && ns != null && name != null,
"wrapped != null && ns != null && name != null");
m_wrapped = wrapped;
m_namespace = ns;
m_name = name;
}
private void AppendEvent(DescriptionBuilder sb, NetBrowserManager manager, EventInfo eventInfo)
{
sb.Append(Settings.GetKeyword(MemberTypes.Event));
sb.Append(" ");
NetTypeBrowserInfo.AppendParameterTypeDisplayName(manager, sb, eventInfo.EventHandlerType, false, true);
sb.Append(" ");
sb.AppendName(eventInfo.Name);
}
internal DescriptionText GetDescription(NetNamespaceBrowserInfo ns, NetTypeBrowserInfo baseType)
{
if (m_description == null)
{
m_description = GetDescriptionInternal(ns, baseType);
Debug.Assert(m_description != null, "m_description != null");
}
return(m_description);
}
internal DescriptionText GetDescription(NetBrowserManager manager, NetTypeBrowserInfo type)
{
if (m_description == null)
{
m_description = GetDescriptionInternal(manager, type);
Debug.Assert(m_description != null, "m_description != null");
}
return(m_description);
}
internal bool TypeShouldBeVisible(Type type)
{
if (ShowNonPublic)
{
return(true);
}
AccessModifiers effectiveAccess = NetTypeBrowserInfo.GetEffectiveTypeAccess(type);
return(effectiveAccess != AccessModifiers.Private && effectiveAccess != AccessModifiers.Internal);
}
internal RemoteTypeBrowserInfo GetRemoteType(NetTypeBrowserInfo realType)
{
if (realType == null)
{
return(null);
}
NetNamespaceBrowserInfo realNs = realType.NamespaceInternal;
RemoteAssemblyBrowserInfo assembly = new RemoteAssemblyBrowserInfo(((NetAssemblyBrowserInfo)realNs.Repository).FilePath, this);
RemoteNamespaceBrowserInfo ns = new RemoteNamespaceBrowserInfo(realNs, assembly, realNs.DisplayName);
return(new RemoteTypeBrowserInfo(realType, ns, realType.FullName));
}
internal NetTypeBrowserInfo GetTypeInfo(Type type, NetNamespaceBrowserInfo ns)
{
Debug.Assert(type != null && ns != null, "type != null && ns != null");
NetTypeBrowserInfo typeInfo = (NetTypeBrowserInfo)m_cachedTypes[type];
if (typeInfo == null)
{
typeInfo = new NetTypeBrowserInfo(type, ns);
m_cachedTypes.Add(type, typeInfo);
}
return(typeInfo);
}
private void AppendProperty(DescriptionBuilder sb, NetBrowserManager manager, PropertyInfo property)
{
// Properties have many of the same attributes as methods, but these attributes are declared
// on the accessors, not on the properties themselves.
MethodInfo[] accessors = property.GetAccessors(true);
Debug.Assert(accessors.Length > 0, "Unable to get the accessors for property '"
+ property.DeclaringType.ToString() + "." + property.Name
+ "' - this property should not have been displayed.");
AppendMethodAttributes(sb, accessors[0]);
NetTypeBrowserInfo.AppendParameterTypeDisplayName(manager, sb, property.PropertyType, false, true);
sb.Append(" ");
sb.AppendName(property.Name);
if (property.CanRead)
{
if (property.CanWrite)
{
sb.Append(" [ get, set ]");
}
else
{
sb.Append(" [ get ]");
}
}
else if (property.CanWrite)
{
sb.Append(" [ set ]");
}
else
{
Debug.Fail("Property '" + property.Name + "' is not readable and not writeable.");
}
// Show indexer parameters as well (which the VS.NET object browser doesn't do).
ParameterInfo[] indexers = property.GetIndexParameters();
if (indexers.Length > 0)
{
sb.Append(" ( ");
AppendParameters(sb, manager, indexers);
sb.Append(" )");
}
}
private DescriptionText GetDescriptionInternal(NetNamespaceBrowserInfo ns, NetTypeBrowserInfo baseType)
{
try
{
DescriptionBuilder sb = new DescriptionBuilder(true);
sb.Append(Settings.GetKeyword(GetTypeAccess(m_type)));
sb.Append(" ");
AppendTypeAttribute(sb, m_type, TypeAttributes.Abstract);
AppendTypeAttribute(sb, m_type, TypeAttributes.Sealed);
sb.Append(Settings.GetKeyword(GetObjectType(m_type)));
sb.Append(" ");
sb.AppendName(GetTypeDisplayName(m_type));
if (baseType != null)
{
sb.Append(" : ");
sb.AppendLink(baseType.DisplayName, baseType);
}
if (m_type.IsEnum)
{
Type underlying = Enum.GetUnderlyingType(m_type);
sb.Append(" (");
sb.AppendName(Settings.GetKeyword(underlying.AssemblyQualifiedName));
sb.Append(")");
}
IElementBrowserInfo container = (ns.IsNullNamespace ? ns.Repository : (IElementBrowserInfo)ns);
sb.EndFirstLine();
sb.Append(@" Member of ");
sb.AppendLink(container.NodeText, container);
sb.EndLine();
return(sb.GetText());
}
catch (System.Exception ex)
{
throw new ApplicationException("Failed to write the type declaration for type '"
+ m_type.FullName + "'.", ex);
}
}
public override int CompareTo(object obj)
{
if (!(obj is NetTypeBrowserInfo))
{
throw new ArgumentException("Object must be of type '" + GetType().FullName + "'.", "obj");
}
NetTypeBrowserInfo other = (NetTypeBrowserInfo)obj;
if (other == this)
{
return(0);
}
switch (Settings.TypeOrder)
{
case TypeOrder.Alphabetical:
return(CompareTypeNames(m_type, other.m_type));
case TypeOrder.ObjectType:
// Compare object types
int result1 = GetObjectType(m_type).CompareTo(GetObjectType(other.m_type));
if (result1 != 0)
{
return(result1);
}
// Same object type - compare names
return(CompareTypeNames(m_type, other.m_type));
case TypeOrder.ObjectAccess:
// Compare object types
int result2 = GetEffectiveTypeAccess(m_type).CompareTo(GetEffectiveTypeAccess(other.m_type));
if (result2 != 0)
{
return(result2);
}
// Same object access - compare names
return(CompareTypeNames(m_type, other.m_type));
default:
throw new ApplicationException("Unsupported TypeOrder enum value: '"
+ Settings.TypeOrder.ToString() + "'.");
}
}
private void AppendField(DescriptionBuilder sb, NetBrowserManager manager, FieldInfo field)
{
AppendFieldAttribute(sb, field, FieldAttributes.Static);
AppendFieldAttribute(sb, field, FieldAttributes.InitOnly);
AppendFieldAttribute(sb, field, FieldAttributes.Literal);
NetTypeBrowserInfo.AppendParameterTypeDisplayName(manager, sb, field.FieldType, false, true);
sb.Append(" ");
sb.AppendName(field.Name);
// Show values of constants, static readonly variables and enum identifiers.
if (field.IsLiteral || (field.IsStatic && field.IsInitOnly))
{
sb.Append(" = ");
sb.Append(GetConstantDisplayValue(field.GetValue(null), true));
}
}
private void AppendMethod(DescriptionBuilder sb, NetBrowserManager manager, MethodInfo method)
{
AppendMethodAttributes(sb, method);
NetTypeBrowserInfo.AppendParameterTypeDisplayName(manager, sb, method.ReturnType, false, true);
sb.Append(" ");
if (MethodIsOperator(method))
{
sb.AppendName(Settings.GetKeyword(method.Name));
}
else
{
sb.AppendName(method.Name);
}
sb.Append(" ( ");
AppendParameters(sb, manager, method.GetParameters());
sb.Append(" )");
}
private DescriptionText GetDescriptionInternal(NetBrowserManager manager, NetTypeBrowserInfo type)
{
DescriptionBuilder sb = new DescriptionBuilder(true);
sb.Append(Settings.GetKeyword(GetMemberAccess(m_memberInfo)));
sb.Append(" ");
switch (m_memberInfo.MemberType)
{
case MemberTypes.Constructor:
AppendConstructor(sb, manager, (ConstructorInfo)m_memberInfo);
break;
case MemberTypes.Method:
AppendMethod(sb, manager, (MethodInfo)m_memberInfo);
break;
case MemberTypes.Property:
AppendProperty(sb, manager, (PropertyInfo)m_memberInfo);
break;
case MemberTypes.Field:
AppendField(sb, manager, (FieldInfo)m_memberInfo);
break;
case MemberTypes.Event:
AppendEvent(sb, manager, (EventInfo)m_memberInfo);
break;
default:
throw new ApplicationException("Unsupported member type: '" + m_memberInfo.MemberType.ToString() + "'.");
}
sb.EndFirstLine();
sb.Append(@" Member of ");
sb.AppendLink(type.DisplayName, type);
sb.EndLine();
return(sb.GetText());
}
public override bool Equals(object obj)
{
NetTypeBrowserInfo other = obj as NetTypeBrowserInfo;
if (other == null)
{
return(false);
}
// The other object may be a RemoteTypeBrowserInfo or just a NetTypeBrowserInfo.
RemoteTypeBrowserInfo otherRemote = other as RemoteTypeBrowserInfo;
if (otherRemote == null)
{
return(object.Equals(Wrapped, other));
}
else
{
return(object.Equals(Wrapped, otherRemote.Wrapped));
}
}
private void CreateWrappedObject()
{
m_wrapped = m_namespace.GetType(m_name);
Debug.Assert(m_wrapped != null, "m_wrapped != null");
}
internal void AddType(NetTypeBrowserInfo type)
{
Debug.Assert(type != null, "type != null");
m_types.Add(type, type.FullName);
}
