private IAssemblyTypeInfo[] QueryAssemblyTypes(
Assembly oAssembly,
IAssemblyQueryFilter oQueryFilter)
{
AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(m_customAssemblyResolver.AssemblyResolveHandler);
try
{
Type[] TypesToExplore = FilterOutTypes(oAssembly, oQueryFilter);
ArrayList oAssemblyTypesInfo = new ArrayList();
foreach (Type oAssemblyType in TypesToExplore)
{
IAssemblyTypeInfo oAssemblyTypeInfo =
QueryTypeMethods(oAssemblyType, oQueryFilter);
if (oAssemblyTypeInfo != null)
{
oAssemblyTypesInfo.Add(oAssemblyTypeInfo);
}
}
return((IAssemblyTypeInfo[])oAssemblyTypesInfo.ToArray(typeof(IAssemblyTypeInfo)));
}
finally
{
AppDomain.CurrentDomain.AssemblyResolve -= new ResolveEventHandler(m_customAssemblyResolver.AssemblyResolveHandler);
}
}
public IAssemblyExplorerQuery QueryMethodsEx(
string sAssemblyName,
IAssemblyQueryFilter QueryFilter)
{
Assembly oAssembly;
try
{
oAssembly = Assembly.LoadFile(sAssemblyName);
}
catch (Exception oExc)
{
Log.WriteException(oExc);
return(null);
}
AssemblyQueryFilter oQueryFilter = null;
if (QueryFilter != EMPTY_QUERY_FILTER)
{
oQueryFilter = new AssemblyQueryFilter(
QueryFilter.TypeName,
QueryFilter.MethodParamsCount,
QueryFilter.MethodTypeOfParams,
QueryFilter.MethodReturnType);
}
return(new AssemblyExplorerQuery(
oAssembly,
oQueryFilter,
CustomizationDir));
}
public AssemblyTypeInfo(
Type oTypeToExplore,
IAssemblyQueryFilter oQueryFilter)
{
m_TypeToExplore = oTypeToExplore;
m_oAssembly = m_TypeToExplore.Assembly;
m_sShortTypeName = GetShortTypeName();
m_TypeMethods = ExploreTypeMethods(oQueryFilter);
}
public AssemblyExplorerQuery(
Assembly oAssembly,
IAssemblyQueryFilter oQueryFilter,
string customizationDir)
: base(oAssembly.GetName().Name, new string[] { })
{
m_sAssemblyName = oAssembly.GetName().Name;
m_customAssemblyResolver = new CustomAssemblyResolver(new BasicConfiguration().eFlowBinPath);
m_customAssemblyResolver.CustomizationDir = customizationDir;
m_AssemblyTypes = QueryAssemblyTypes(oAssembly, oQueryFilter);
m_referencedAssemblies = QueryReferencedAssemblies(oAssembly);
}
private IAssemblyTypeInfo QueryTypeMethods(
Type oAssemblyType,
IAssemblyQueryFilter oQueryFilter)
{
IAssemblyTypeInfo oAssemblyTypeInfo =
new AssemblyTypeInfo(oAssemblyType, oQueryFilter);
if (oAssemblyTypeInfo.TypeMethodsCount > 0)
{
return(oAssemblyTypeInfo);
}
else
{
return(null);
}
}
public IAssemblyExplorerQuery QueryMethods(
string sAssemblyName,
string TypeNameFilter,
int MethodParamsCountFilter,
[MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_VARIANT)]
string[] MethodTypeOfParamsFilter,
string MethodReturnTypeFilter)
{
IAssemblyQueryFilter oQueryFilter = (IAssemblyQueryFilter)GetQueryFilter(
TypeNameFilter,
MethodParamsCountFilter,
MethodTypeOfParamsFilter,
MethodReturnTypeFilter);
return(QueryMethodsEx(
sAssemblyName,
oQueryFilter));
}
private string[] ExploreTypeMethods(IAssemblyQueryFilter oQueryFilter)
{
MethodInfo[] TypePublicMethods = FilterOutTypeMethods(
m_TypeToExplore.GetMethods(),
oQueryFilter);
ArrayList m_MethodNames = new ArrayList();
foreach (MethodInfo oMethod in TypePublicMethods)
{
if (!m_MethodNames.Contains(oMethod.Name))
{
m_MethodNames.Add(oMethod.Name);
}
}
return((string [])m_MethodNames.ToArray(typeof(string)));
}
private Type[] FilterOutTypes(
Assembly oAssembly,
IAssemblyQueryFilter oQueryFilter)
{
ArrayList oAssemblyTypes = new ArrayList();
Type[] AssemblyPublicTypes = oAssembly.GetTypes();
Type oCheckedType = null;
bool bFilterByType = oQueryFilter != null &&
oQueryFilter.TypeName != null &&
oQueryFilter.TypeName != String.Empty;
if (bFilterByType)
{
oCheckedType = AssemblyTypeInfo.GetTypeByName(oQueryFilter.TypeName, oAssembly);
}
foreach (Type oAssemblyType in AssemblyPublicTypes)
{
bool bShouldBeConsidered =
oAssemblyType.IsClass &&
(oAssemblyType.IsPublic || oAssemblyType.IsNestedPublic);
if (bShouldBeConsidered && bFilterByType)
{
bShouldBeConsidered = oCheckedType != null &&
oCheckedType.Equals(oAssemblyType);
}
if (bShouldBeConsidered)
{
oAssemblyTypes.Add(oAssemblyType);
}
}
return((Type[])oAssemblyTypes.ToArray(typeof(Type)));
}
private MethodInfo[] FilterOutTypeMethods(
MethodInfo[] TypePublicMethods,
IAssemblyQueryFilter oQueryFilter)
{
bool bFilterByParamsCount = oQueryFilter != null && oQueryFilter.MethodParamsCount > -1;
Type [] TypeArray = null;
bool bFilterByParamsType = oQueryFilter != null &&
oQueryFilter.MethodTypeOfParams != null;
if (bFilterByParamsType)
{
TypeArray = GetTypesByName(oQueryFilter.MethodTypeOfParams);
}
Type oReturnType = null;
bool bFilterByReturnType = oQueryFilter != null &&
oQueryFilter.MethodReturnType != null;
if (bFilterByReturnType)
{
oReturnType = GetTypeByName(oQueryFilter.MethodReturnType, m_oAssembly);
bFilterByReturnType = oReturnType != null;
}
ArrayList oFilteredMethods = new ArrayList();
oFilteredMethods.AddRange(TypePublicMethods);
if (bFilterByParamsCount || bFilterByParamsType || bFilterByReturnType)
{
using (AssemblyVersionIgnorer versionResolver = new AssemblyVersionIgnorer())
{
foreach (MethodInfo oMethodInfo in TypePublicMethods)
{
bool bShouldBeFilteredOut = bFilterByParamsCount &&
oQueryFilter.MethodParamsCount != oMethodInfo.GetParameters().Length;
if (!bShouldBeFilteredOut && bFilterByParamsType)
{
bShouldBeFilteredOut =
m_TypeToExplore.GetMethod(
oMethodInfo.Name,
BindingFlags.ExactBinding |
BindingFlags.IgnoreCase |
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.Static,
null,
TypeArray,
new ParameterModifier[0]) == null;
}
if (!bShouldBeFilteredOut && bFilterByReturnType)
{
bShouldBeFilteredOut = oMethodInfo.ReturnType != oReturnType;
}
if (bShouldBeFilteredOut)
{
oFilteredMethods.Remove(oMethodInfo);
}
}
}
}
return((MethodInfo [])oFilteredMethods.ToArray(typeof(MethodInfo)));
}
