public ClassViewWindow(IAssemblyBrowser assemblyBrowser, ILanguageManager languageManager, ITranslatorManager translatorManager, IVisibilityConfiguration visibilityConfiguration)
{
this.Dock = DockStyle.Fill;
this.Multiline = true;
this.WordWrap = false;
this.ReadOnly = true;
this.Font = new Font("Courier New", 9f);
this.ScrollBars = RichTextBoxScrollBars.Both;
this.BorderStyle = BorderStyle.None;
this.ContextMenu = new ContextMenu();
this.ContextMenu.MenuItems.Add("Select &All", new EventHandler(this.SelectAll_Click)).Shortcut = Shortcut.CtrlA;
this.ContextMenu.MenuItems.Add("-");
this.ContextMenu.MenuItems.Add("&Copy", new EventHandler(this.Copy_Click)).Shortcut = Shortcut.CtrlC;
this.assemblyBrowser = assemblyBrowser;
if (this.assemblyBrowser != null)
{
this.assemblyBrowser.ActiveItemChanged += new EventHandler(this.AssemblyBrowser_ActiveItemChanged);
}
this.languageManager = languageManager;
if (this.languageManager != null)
{
this.languageManager.ActiveLanguageChanged += new EventHandler(this.LanguageManager_ActiveLanguageChanged);
}
this.translatorManager = translatorManager;
this.visibilityConfiguration = visibilityConfiguration;
}
/// <summary>
/// Initializes a new instance of the <see cref="DerivedTypeInformation"/> class.
/// </summary>
/// <param name="assemblyManager">The assembly manager.</param>
/// <param name="visibility">The visibility.</param>
public DerivedTypeInformation(IAssemblyManager assemblyManager, IVisibilityConfiguration visibility)
{
this.table = new Dictionary<ITypeReference, List<ITypeDeclaration>>();
IAssembly[] assemblies = new IAssembly[assemblyManager.Assemblies.Count];
assemblyManager.Assemblies.CopyTo(assemblies, 0);
FastTypeEnumerator enumerator = new FastTypeEnumerator(assemblies);
foreach (ITypeDeclaration typeDeclaration in enumerator.Types)
{
if (ReflectorHelper.IsVisible(typeDeclaration, visibility))
{
ITypeReference baseType = typeDeclaration.BaseType;
if (baseType != null)
{
if (baseType.GenericType != null)
{
this.AddToTable(baseType.GenericType, typeDeclaration);
}
else
{
this.AddToTable(baseType, typeDeclaration);
}
}
foreach (ITypeReference interfaceType in typeDeclaration.Interfaces)
{
this.AddToTable(interfaceType, typeDeclaration);
}
}
}
}
public static bool IsVisible(IMethodReference value, IVisibilityConfiguration visibility)
{
if (Helper.IsVisible(value.DeclaringType, visibility))
{
IMethodDeclaration methodDeclaration = value.Resolve();
switch (methodDeclaration.Visibility)
{
case MethodVisibility.Public:
return(visibility.Public);
case MethodVisibility.Assembly:
return(visibility.Assembly);
case MethodVisibility.FamilyOrAssembly:
return(visibility.FamilyOrAssembly);
case MethodVisibility.Family:
return(visibility.Family);
case MethodVisibility.Private:
case MethodVisibility.PrivateScope:
return(visibility.Private);
case MethodVisibility.FamilyAndAssembly:
return(visibility.FamilyAndAssembly);
}
throw new NotSupportedException();
}
return(false);
}
public static ICollection GetNestedTypes(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
ITypeDeclarationCollection nestedTypes = value.NestedTypes;
ICollection result;
if (nestedTypes.Count > 0)
{
ArrayList arrayList = new ArrayList(0);
foreach (object obj in nestedTypes)
{
ITypeDeclaration value2 = (ITypeDeclaration)obj;
if (IsVisible(value2, visibility))
{
arrayList.Add(value2);
}
}
arrayList.Sort();
result = arrayList;
}
else
{
result = new ITypeDeclaration[0];
}
return(result);
}
public static bool IsVisible(IPropertyReference value, IVisibilityConfiguration visibility)
{
if (IsVisible(value.DeclaringType, visibility))
{
switch (GetVisibility(value))
{
case MethodVisibility.PrivateScope:
case MethodVisibility.Private:
return(visibility.Private);
case MethodVisibility.FamilyAndAssembly:
return(visibility.FamilyAndAssembly);
case MethodVisibility.Assembly:
return(visibility.Assembly);
case MethodVisibility.Family:
return(visibility.Family);
case MethodVisibility.FamilyOrAssembly:
return(visibility.FamilyOrAssembly);
case MethodVisibility.Public:
return(visibility.Public);
}
throw new NotSupportedException();
}
return(false);
}
public static ICollection GetEvents(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
IEventDeclarationCollection events = value.Events;
ICollection result;
if (events.Count > 0)
{
ArrayList arrayList = new ArrayList(0);
foreach (object obj in events)
{
IEventDeclaration value2 = (IEventDeclaration)obj;
if (visibility == null || IsVisible(value2, visibility))
{
arrayList.Add(value2);
}
}
arrayList.Sort();
result = arrayList;
}
else
{
result = new IEventDeclaration[0];
}
return(result);
}
public static ICollection GetProperties(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
IPropertyDeclarationCollection properties = value.Properties;
ICollection result;
if (properties.Count > 0)
{
ArrayList arrayList = new ArrayList(0);
foreach (object obj in properties)
{
IPropertyDeclaration value2 = (IPropertyDeclaration)obj;
if (visibility == null || IsVisible(value2, visibility))
{
arrayList.Add(value2);
}
}
arrayList.Sort();
result = arrayList;
}
else
{
result = new IPropertyDeclaration[0];
}
return(result);
}
void IPackage.Load(IServiceProvider serviceProvider)
{
this.serviceProvider = serviceProvider;
this.windowManager = (IWindowManager)this.serviceProvider.GetService(typeof(IWindowManager));
this.commandbarManager = (ICommandBarManager)this.serviceProvider.GetService(typeof(ICommandBarManager));
// manage the search window
this.windowManager.Windows.Add("SearchCodeWindow", this, "Code Search " + this.GetType().Assembly.GetName().Version.ToString());
// load the resources
System.Reflection.Assembly myAssembly = System.Reflection.Assembly.GetExecutingAssembly();
Stream myStream = myAssembly.GetManifestResourceStream("Reflector.CodeSearch.Search.png");
Bitmap img = null;
if (myStream != null)
{
img = new Bitmap(myStream);
}
// add the toolbar button
evtSearch = new EventHandler(this.CodeSearchButton_Click);
this.toolBarSeparator = commandbarManager.CommandBars["ToolBar"].Items.AddSeparator();
this.toolBarButton = commandbarManager.CommandBars["ToolBar"].Items.AddButton("Code Search", img, evtSearch);
this.menuBarSeparator = commandbarManager.CommandBars["Tools"].Items.AddSeparator();
this.menuBarButton = commandbarManager.CommandBars["Tools"].Items.AddButton("Code Search", img, evtSearch);
// init members
this.assemblyBrowser = (IAssemblyBrowser)serviceProvider.GetService(typeof(IAssemblyBrowser));
this.languageManager = (ILanguageManager)serviceProvider.GetService(typeof(ILanguageManager));
this.translatorManager = (ITranslatorManager)serviceProvider.GetService(typeof(ITranslatorManager));
this.visibilityConfiguration = (IVisibilityConfiguration)serviceProvider.GetService(typeof(IVisibilityConfiguration));
}
public static bool IsVisible(IType value, IVisibilityConfiguration visibility)
{
if (value is ITypeReference typeReference)
{
if (typeReference.Owner is ITypeReference typeReference2)
{
if (!IsVisible(typeReference2, visibility))
{
return(false);
}
}
ITypeDeclaration typeDeclaration = typeReference.Resolve();
bool result;
if (typeDeclaration == null)
{
result = true;
}
else
{
switch (typeDeclaration.Visibility)
{
case TypeVisibility.Private:
case TypeVisibility.NestedPrivate:
result = visibility.Private;
break;
case TypeVisibility.Public:
case TypeVisibility.NestedPublic:
result = visibility.Public;
break;
case TypeVisibility.NestedFamily:
result = visibility.Family;
break;
case TypeVisibility.NestedAssembly:
result = visibility.Assembly;
break;
case TypeVisibility.NestedFamilyAndAssembly:
result = visibility.FamilyAndAssembly;
break;
case TypeVisibility.NestedFamilyOrAssembly:
result = visibility.FamilyOrAssembly;
break;
default:
throw new NotImplementedException();
}
}
return(result);
}
throw new NotSupportedException();
}
public static bool IsVisible(IFieldReference value, IVisibilityConfiguration visibility)
{
bool result;
if (IsVisible(value.DeclaringType, visibility))
{
IFieldDeclaration fieldDeclaration = value.Resolve();
if (fieldDeclaration == null)
{
result = true;
}
else
{
switch (fieldDeclaration.Visibility)
{
case FieldVisibility.PrivateScope:
result = visibility.Private;
break;
case FieldVisibility.Private:
result = visibility.Private;
break;
case FieldVisibility.FamilyAndAssembly:
result = visibility.FamilyAndAssembly;
break;
case FieldVisibility.Assembly:
result = visibility.Assembly;
break;
case FieldVisibility.Family:
result = visibility.Family;
break;
case FieldVisibility.FamilyOrAssembly:
result = visibility.FamilyOrAssembly;
break;
case FieldVisibility.Public:
result = visibility.Public;
break;
default:
throw new NotSupportedException();
}
}
}
else
{
result = false;
}
return(result);
}
public static ICollection GetMethods(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
IMethodDeclarationCollection methods = value.Methods;
ICollection result;
if (methods.Count > 0)
{
ArrayList arrayList = new ArrayList(0);
foreach (object obj in methods)
{
IMethodDeclaration value2 = (IMethodDeclaration)obj;
if (visibility == null || IsVisible(value2, visibility))
{
arrayList.Add(value2);
}
}
foreach (object obj2 in value.Properties)
{
IPropertyDeclaration propertyDeclaration = (IPropertyDeclaration)obj2;
if (propertyDeclaration.SetMethod != null)
{
arrayList.Remove(propertyDeclaration.SetMethod.Resolve());
}
if (propertyDeclaration.GetMethod != null)
{
arrayList.Remove(propertyDeclaration.GetMethod.Resolve());
}
}
foreach (object obj3 in value.Events)
{
IEventDeclaration eventDeclaration = (IEventDeclaration)obj3;
if (eventDeclaration.AddMethod != null)
{
arrayList.Remove(eventDeclaration.AddMethod.Resolve());
}
if (eventDeclaration.RemoveMethod != null)
{
arrayList.Remove(eventDeclaration.RemoveMethod.Resolve());
}
if (eventDeclaration.InvokeMethod != null)
{
arrayList.Remove(eventDeclaration.InvokeMethod.Resolve());
}
}
arrayList.Sort();
result = arrayList;
}
else
{
result = new IMethodDeclaration[0];
}
return(result);
}
public static ICollection GetMethods(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
IMethodDeclarationCollection methods = value.Methods;
if (methods.Count > 0)
{
ArrayList list = new ArrayList(0);
foreach (IMethodDeclaration methodDeclaration in methods)
{
if ((visibility == null) || (IsVisible(methodDeclaration, visibility)))
{
list.Add(methodDeclaration);
}
}
foreach (IPropertyDeclaration propertyDeclaration in value.Properties)
{
if (propertyDeclaration.SetMethod != null)
{
list.Remove(propertyDeclaration.SetMethod.Resolve());
}
if (propertyDeclaration.GetMethod != null)
{
list.Remove(propertyDeclaration.GetMethod.Resolve());
}
}
foreach (IEventDeclaration eventDeclaration in value.Events)
{
if (eventDeclaration.AddMethod != null)
{
list.Remove(eventDeclaration.AddMethod.Resolve());
}
if (eventDeclaration.RemoveMethod != null)
{
list.Remove(eventDeclaration.RemoveMethod.Resolve());
}
if (eventDeclaration.InvokeMethod != null)
{
list.Remove(eventDeclaration.InvokeMethod.Resolve());
}
}
list.Sort();
return(list);
}
return(new IMethodDeclaration[0]);
}
public static bool IsVisible(IType value, IVisibilityConfiguration visibility)
{
ITypeReference typeReference = value as ITypeReference;
if (typeReference != null)
{
ITypeReference declaringType = typeReference.Owner as ITypeReference;
if (declaringType != null)
{
if (!Helper.IsVisible(declaringType, visibility))
{
return(false);
}
}
ITypeDeclaration typeDeclaration = typeReference.Resolve();
if (typeDeclaration == null)
{
return(true);
}
switch (typeDeclaration.Visibility)
{
case TypeVisibility.Public:
case TypeVisibility.NestedPublic:
return(visibility.Public);
case TypeVisibility.Private:
case TypeVisibility.NestedPrivate:
return(visibility.Private);
case TypeVisibility.NestedFamilyOrAssembly:
return(visibility.FamilyOrAssembly);
case TypeVisibility.NestedFamily:
return(visibility.Family);
case TypeVisibility.NestedFamilyAndAssembly:
return(visibility.FamilyAndAssembly);
case TypeVisibility.NestedAssembly:
return(visibility.Assembly);
default:
throw new NotImplementedException();
}
}
throw new NotSupportedException();
}
public static ICollection GetInterfaces(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
ArrayList list = new ArrayList(0);
foreach (ITypeReference reference in GetInterfaces(value))
{
if (IsVisible(reference, visibility))
{
list.Add(reference);
}
}
list.Sort();
return(list);
}
public static ICollection GetInterfaces(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
ArrayList arrayList = new ArrayList(0);
foreach (object obj in GetInterfaces(value))
{
ITypeReference value2 = (ITypeReference)obj;
if (IsVisible(value2, visibility))
{
arrayList.Add(value2);
}
}
arrayList.Sort();
return(arrayList);
}
public void Load(IServiceProvider serviceProvider)
{
IAssemblyBrowser assemblyBrowser = (IAssemblyBrowser)serviceProvider.GetService(typeof(IAssemblyBrowser));
ILanguageManager languageManager = (ILanguageManager)serviceProvider.GetService(typeof(ILanguageManager));
ITranslatorManager translatorManager = (ITranslatorManager)serviceProvider.GetService(typeof(ITranslatorManager));
IVisibilityConfiguration visibilityConfiguration = (IVisibilityConfiguration)serviceProvider.GetService(typeof(IVisibilityConfiguration));
this.window = new ClassViewWindow(assemblyBrowser, languageManager, translatorManager, visibilityConfiguration);
this.windowManager = (IWindowManager)serviceProvider.GetService(typeof(IWindowManager));
this.windowManager.Windows.Add("ClassViewWindow", this.window, "Class View");
this.commandBarManager = (ICommandBarManager)serviceProvider.GetService(typeof(ICommandBarManager));
this.separator = commandBarManager.CommandBars["Tools"].Items.AddSeparator();
this.button = commandBarManager.CommandBars["Tools"].Items.AddButton("Class &View", new EventHandler(this.Button_Click));
}
public static ICollection GetEvents(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
ArrayList list = new ArrayList(0);
IEventDeclarationCollection events = value.Events;
if (events.Count > 0)
{
foreach (IEventDeclaration declaration in events)
{
if ((visibility == null) || IsVisible(declaration, visibility))
{
list.Add(declaration);
}
}
list.Sort();
}
return(list);
}
public static ICollection GetNestedTypes(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
ArrayList list = new ArrayList(0);
ITypeDeclarationCollection nestedTypes = value.NestedTypes;
if (nestedTypes.Count > 0)
{
foreach (ITypeDeclaration declaration in nestedTypes)
{
if (IsVisible(declaration, visibility))
{
list.Add(declaration);
}
}
list.Sort();
}
return(list);
}
public static ICollection GetProperties(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
ArrayList list = new ArrayList(0);
IPropertyDeclarationCollection properties = value.Properties;
if (properties.Count > 0)
{
foreach (IPropertyDeclaration declaration in properties)
{
if ((visibility == null) || IsVisible(declaration, visibility))
{
list.Add(declaration);
}
}
list.Sort();
}
return(list);
}
public static ICollection GetFields(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
ArrayList list = new ArrayList(0);
IFieldDeclarationCollection fields = value.Fields;
if (fields.Count > 0)
{
foreach (IFieldDeclaration declaration in fields)
{
if ((visibility == null) || IsVisible(declaration, visibility))
{
list.Add(declaration);
}
}
list.Sort();
}
return(list);
}
public static bool IsVisible(IType value, IVisibilityConfiguration visibility)
{
ITypeReference reference = value as ITypeReference;
if (reference == null)
{
throw new NotSupportedException();
}
ITypeReference owner = reference.Owner as ITypeReference;
if ((owner != null) && !IsVisible(owner, visibility))
{
return(false);
}
ITypeDeclaration declaration = reference.Resolve();
if (declaration == null)
{
return(true);
}
switch (declaration.Visibility)
{
case TypeVisibility.Private:
case TypeVisibility.NestedPrivate:
return(visibility.Private);
case TypeVisibility.Public:
case TypeVisibility.NestedPublic:
return(visibility.Public);
case TypeVisibility.NestedFamily:
return(visibility.Family);
case TypeVisibility.NestedAssembly:
return(visibility.Assembly);
case TypeVisibility.NestedFamilyAndAssembly:
return(visibility.FamilyAndAssembly);
case TypeVisibility.NestedFamilyOrAssembly:
return(visibility.FamilyOrAssembly);
}
throw new NotImplementedException();
}
public static bool IsVisible(IEventReference value, IVisibilityConfiguration visibility)
{
bool result;
if (IsVisible(value.DeclaringType, visibility))
{
switch (GetVisibility(value))
{
case MethodVisibility.PrivateScope:
case MethodVisibility.Private:
result = visibility.Private;
break;
case MethodVisibility.FamilyAndAssembly:
result = visibility.FamilyAndAssembly;
break;
case MethodVisibility.Assembly:
result = visibility.Assembly;
break;
case MethodVisibility.Family:
result = visibility.Family;
break;
case MethodVisibility.FamilyOrAssembly:
result = visibility.FamilyOrAssembly;
break;
case MethodVisibility.Public:
result = visibility.Public;
break;
default:
throw new NotSupportedException();
}
}
else
{
result = false;
}
return(result);
}
public static ICollection GetFields(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
IFieldDeclarationCollection fields = value.Fields;
if (fields.Count > 0)
{
ArrayList arrayList = new ArrayList(0);
foreach (object obj in fields)
{
IFieldDeclaration value2 = (IFieldDeclaration)obj;
if (visibility == null || IsVisible(value2, visibility))
{
arrayList.Add(value2);
}
}
arrayList.Sort();
return(arrayList);
}
return(new IFieldDeclaration[0]);
}
public static ICollection GetFields(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
ArrayList list = new ArrayList(0);
IFieldDeclarationCollection fields = value.Fields;
if (fields.Count > 0)
{
foreach (IFieldDeclaration fieldDeclaration in fields)
{
if ((visibility == null) || (IsVisible(fieldDeclaration, visibility)))
{
list.Add(fieldDeclaration);
}
}
list.Sort();
}
return list;
}
public static ICollection GetEvents(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
ArrayList list = new ArrayList(0);
IEventDeclarationCollection events = value.Events;
if (events.Count > 0)
{
foreach (IEventDeclaration eventDeclaration in events)
{
if ((visibility == null) || (IsVisible(eventDeclaration, visibility)))
{
list.Add(eventDeclaration);
}
}
list.Sort();
}
return list;
}
public static ICollection GetNestedTypes(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
ITypeDeclarationCollection nestedTypes = value.NestedTypes;
if (nestedTypes.Count > 0)
{
ArrayList list = new ArrayList(0);
foreach (ITypeDeclaration nestedType in nestedTypes)
{
if (Helper.IsVisible(nestedType, visibility))
{
list.Add(nestedType);
}
}
list.Sort();
return(list);
}
return(new ITypeDeclaration[0]);
}
public static bool IsVisible(IFieldReference value, IVisibilityConfiguration visibility)
{
if (IsVisible(value.DeclaringType, visibility))
{
IFieldDeclaration fieldDeclaration = value.Resolve();
if (fieldDeclaration == null)
{
return(true);
}
switch (fieldDeclaration.Visibility)
{
case FieldVisibility.Public:
return(visibility.Public);
case FieldVisibility.Assembly:
return(visibility.Assembly);
case FieldVisibility.FamilyOrAssembly:
return(visibility.FamilyOrAssembly);
case FieldVisibility.Family:
return(visibility.Family);
case FieldVisibility.Private:
return(visibility.Private);
case FieldVisibility.FamilyAndAssembly:
return(visibility.FamilyAndAssembly);
case FieldVisibility.PrivateScope:
return(visibility.Private);
}
throw new NotSupportedException();
}
return(false);
}
public static ICollection GetMethods(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
ArrayList list = new ArrayList(0);
IMethodDeclarationCollection methods = value.Methods;
if (methods.Count > 0)
{
foreach (IMethodDeclaration methodDeclaration in methods)
{
if ((visibility == null) || (IsVisible(methodDeclaration, visibility)))
{
list.Add(methodDeclaration);
}
}
foreach (IPropertyDeclaration propertyDeclaration in value.Properties)
{
if (propertyDeclaration.SetMethod != null)
{
list.Remove(propertyDeclaration.SetMethod.Resolve());
}
if (propertyDeclaration.GetMethod != null)
{
list.Remove(propertyDeclaration.GetMethod.Resolve());
}
}
foreach (IEventDeclaration eventDeclaration in value.Events)
{
if (eventDeclaration.AddMethod != null)
{
list.Remove(eventDeclaration.AddMethod.Resolve());
}
if (eventDeclaration.RemoveMethod != null)
{
list.Remove(eventDeclaration.RemoveMethod.Resolve());
}
if (eventDeclaration.InvokeMethod != null)
{
list.Remove(eventDeclaration.InvokeMethod.Resolve());
}
}
list.Sort();
}
return list;
}
public static bool IsVisible(IEventReference value, IVisibilityConfiguration visibility)
{
if (IsVisible(value.DeclaringType, visibility))
{
switch (GetVisibility(value))
{
case MethodVisibility.Public :
return visibility.Public;
case MethodVisibility.Assembly :
return visibility.Assembly;
case MethodVisibility.FamilyOrAssembly :
return visibility.FamilyOrAssembly;
case MethodVisibility.Family :
return visibility.Family;
case MethodVisibility.Private:
case MethodVisibility.PrivateScope:
return visibility.Private;
case MethodVisibility.FamilyAndAssembly :
return visibility.FamilyAndAssembly;
}
throw new NotSupportedException();
}
return false;
}
public static bool IsVisible(IFieldReference value, IVisibilityConfiguration visibility)
{
if (IsVisible(value.DeclaringType, visibility))
{
IFieldDeclaration fieldDeclaration = value.Resolve();
if (fieldDeclaration == null)
{
return true;
}
switch (fieldDeclaration.Visibility)
{
case FieldVisibility.Public:
return visibility.Public;
case FieldVisibility.Assembly:
return visibility.Assembly;
case FieldVisibility.FamilyOrAssembly:
return visibility.FamilyOrAssembly;
case FieldVisibility.Family:
return visibility.Family;
case FieldVisibility.Private:
return visibility.Private;
case FieldVisibility.FamilyAndAssembly:
return visibility.FamilyAndAssembly;
case FieldVisibility.PrivateScope:
return visibility.Private;
}
throw new NotSupportedException();
}
return false;
}
public static bool IsVisible(IType value, IVisibilityConfiguration visibility)
{
ITypeReference typeReference = value as ITypeReference;
if (typeReference != null)
{
ITypeReference declaringType = typeReference.Owner as ITypeReference;
if (declaringType != null)
{
if (!IsVisible(declaringType, visibility))
{
return false;
}
}
ITypeDeclaration typeDeclaration = typeReference.Resolve();
if (typeDeclaration == null)
{
return true;
}
switch (typeDeclaration.Visibility)
{
case TypeVisibility.Public:
case TypeVisibility.NestedPublic:
return visibility.Public;
case TypeVisibility.Private:
case TypeVisibility.NestedPrivate:
return visibility.Private;
case TypeVisibility.NestedFamilyOrAssembly:
return visibility.FamilyOrAssembly;
case TypeVisibility.NestedFamily:
return visibility.Family;
case TypeVisibility.NestedFamilyAndAssembly:
return visibility.FamilyAndAssembly;
case TypeVisibility.NestedAssembly:
return visibility.Assembly;
default:
throw new NotImplementedException();
}
}
throw new NotSupportedException();
}
public static ICollection GetProperties(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
ArrayList list = new ArrayList(0);
IPropertyDeclarationCollection properties = value.Properties;
if (properties.Count > 0)
{
foreach (IPropertyDeclaration propertyDeclaration in properties)
{
if ((visibility == null) || (IsVisible(propertyDeclaration, visibility)))
{
list.Add(propertyDeclaration);
}
}
list.Sort();
}
return list;
}
public static bool IsVisible(IMethodReference value, IVisibilityConfiguration visibility)
{
if (Helper.IsVisible(value.DeclaringType, visibility))
{
IMethodDeclaration methodDeclaration = value.Resolve();
switch (methodDeclaration.Visibility)
{
case MethodVisibility.Public:
return visibility.Public;
case MethodVisibility.Assembly:
return visibility.Assembly;
case MethodVisibility.FamilyOrAssembly:
return visibility.FamilyOrAssembly;
case MethodVisibility.Family:
return visibility.Family;
case MethodVisibility.Private:
case MethodVisibility.PrivateScope:
return visibility.Private;
case MethodVisibility.FamilyAndAssembly:
return visibility.FamilyAndAssembly;
}
throw new NotSupportedException();
}
return false;
}
/// <summary>
/// Determines whether the specified value is visible.
/// </summary>
/// <param name="value">The property reference value.</param>
/// <param name="visibility">The visibility.</param>
/// <returns>
/// <c>true</c> if the specified value is visible; otherwise, <c>false</c>.
/// </returns>
internal static bool IsVisible(IPropertyReference value, IVisibilityConfiguration visibility)
{
if (ReflectorHelper.IsVisible(value.DeclaringType, visibility))
{
switch (ReflectorHelper.GetVisibility(value))
{
case MethodVisibility.Public:
return visibility.Public;
case MethodVisibility.Assembly:
return visibility.Assembly;
case MethodVisibility.FamilyOrAssembly:
return visibility.FamilyOrAssembly;
case MethodVisibility.Family:
return visibility.Family;
case MethodVisibility.Private:
case MethodVisibility.PrivateScope:
return visibility.Private;
case MethodVisibility.FamilyAndAssembly:
return visibility.FamilyAndAssembly;
}
throw new InvalidOperationException();
}
return false;
}
public static ICollection GetNestedTypes(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
ArrayList list = new ArrayList(0);
ITypeDeclarationCollection nestedTypes = value.NestedTypes;
if (nestedTypes.Count > 0)
{
foreach (ITypeDeclaration nestedType in nestedTypes)
{
if (IsVisible(nestedType, visibility))
{
list.Add(nestedType);
}
}
list.Sort();
}
return list;
}
public static ICollection GetInterfaces(ITypeDeclaration value, IVisibilityConfiguration visibility)
{
ArrayList list = new ArrayList(0);
foreach (ITypeReference typeReference in GetInterfaces(value))
{
if (IsVisible(typeReference, visibility))
{
list.Add(typeReference);
}
}
list.Sort();
return list;
}
