public virtual bool ExtractAndValidateTypeQuery(string query)
{
Match m = new Regex(@" *(?<typeName>.*?) *\( *(?<innerQuery>.*) *\) *").Match(query);
if (m.Success)
{
myTypeQueries = TypeQuery.GetQueries(m.Groups["typeName"].Value, TypeQueryMode.All);
myInnerQuery = m.Groups["innerQuery"].Value;
return(true);
}
else
{
int opening = CountChars('(', query);
int closing = CountChars(')', query);
if (opening == 0)
{
Out.WriteLine("The query should contain at least one opening brace");
}
else if (opening - closing != 0)
{
Out.WriteLine("The query {0} has not all braces closed.", query);
}
return(false);
}
}
public void PrintVariousEvents()
{
TypeDefinition classWithManyEvents = TypeQuery.GetTypeByName(
TestConstants.BaseLibV1Assembly,
"BaseLibrary.EventQueries.ClassWithManyEvents");
string[] evDefinitions = new string[]
{
"public event Func<int> PublicEvent",
"public event Func<bool> PublicEvent2",
"protected event Func<int> ProtectedEvent",
"internal event Func<int> InternalEvent",
"private event System.Action PrivateEvent",
"public virtual event Func<int> PublicVirtualEvent",
"public static event System.Action PublicStaticEvent",
"private event EventHandler<EventArgs> SceneChanged"
};
foreach (EventDefinition ev in classWithManyEvents.Events)
{
string evStr = ev.Print();
Console.WriteLine("{0}", evStr);
Assert.IsTrue(evDefinitions.Contains(evStr), "Event string should be part of list");
}
}
public void Get_Generic_Type_With_One_Generic_Argument()
{
var query = new TypeQuery(TestConstants.TypeEquivalenceNS, "Class1<A>");
var genericTypes = query.GetTypes(TestConstants.BaseLibV1Assembly);
Assert.AreEqual(1, genericTypes.Count, "Should get one instance");
}
public void Can_Find_IDisposable_Implementer_Without_Pdb()
{
var iDisposable = TypeQuery.GetTypeByName(TestConstants.MscorlibAssembly, "System.IDisposable");
UsageQueryAggregator agg = new UsageQueryAggregator();
new WhoImplementsInterface(agg, iDisposable);
try
{
agg.Analyze(TestConstants.DependandLibV1Assembly);
var results = agg.TypeMatches;
Assert.AreEqual(2, results.Count);
}
finally
{
if (ExceptionHelper.InException)
{
foreach (var typeMatch in agg.TypeMatches)
{
Console.WriteLine("IDisposable is implemeted by {0}: {1}", typeMatch.Match.Print(), typeMatch.SourceFileName);
}
}
}
}
public static void Main(string[] _)
{
Registry.RegisterAll();
EcsTable ecsTable = new EcsTable();
// ecsTable.CreateEntity<(Health, Transform)>();
// ecsTable.CreateEntity<(Health, Transform)>();
ecsTable.CreateEntity <(Health, Transform)>();
ecsTable.CreateEntity <(Health, Transform, TestComp)>();
// TypeQuery query = new TypeQuery()
// .With<Health>();
//
// TypeQueryResults results = query.Execute(ecsTable);
// var iter = results.Restrict<(Health, Transform)>();
var iter = new TypeQuery()
.With <Health>()
.With <Transform>()
.Execute(ecsTable)
.GetIterator();
while (iter.MoveNext())
{
var(health, transform) = iter.Current <Health, Transform>();
health.Unwrap().value = 500;
}
ecsTable.DebugClass <(Health, Transform)>();
ecsTable.DebugClass <(Health, Transform, TestComp)>();
}
public static Task<IEnumerable<Type>> FindTypes(IEnumerable<Assembly> assemblies, TypeClassification classification, Func<Type, bool> filter = null)
{
var query = new TypeQuery(classification, filter);
Task<IEnumerable<Type>>[] tasks = assemblies.Select(assem => ForAssembly(assem).ContinueWith(t => query.Find(t.Result))).ToArray();
return Task.Factory.ContinueWhenAll(tasks, results => results.SelectMany(x => x.Result));
}
public static Task <IEnumerable <Type> > FindTypes(IEnumerable <Assembly> assemblies, TypeClassification classification, Func <Type, bool> filter = null)
{
var query = new TypeQuery(classification, filter);
Task <IEnumerable <Type> >[] tasks = assemblies.Select(assem => ForAssembly(assem).ContinueWith(t => query.Find(t.Result))).ToArray();
return(Task.Factory.ContinueWhenAll(tasks, results => results.SelectMany(x => x.Result)));
}
public void Can_Find_Non_Compilergenerated_Generic_Field()
{
UsageQueryAggregator agg = new UsageQueryAggregator(
new TypeQuery("BaseLibrary.FieldQuery", "PublicClassWithManyEventsAndMethods"));
TypeDefinition func = TypeQuery.GetTypeByName(TestConstants.MscorlibAssembly, "System.Collections.Generic.KeyValuePair`2");
new WhoHasFieldOfType(agg, func);
try
{
agg.Analyze(TestConstants.BaseLibV1Assembly);
Assert.AreEqual(1, agg.FieldMatches.Count, "Field match count");
Assert.AreEqual("ProtectedKeyValuePairField", agg.FieldMatches[0].Match.Name, "Field Name");
}
finally
{
if (ExceptionHelper.InException)
{
foreach (var res in agg.FieldMatches)
{
Console.WriteLine("Found field: {0}, file: {1}", res.Match.Print(FieldPrintOptions.All), res.SourceFileName);
}
}
}
}
public void Can_Find_Field_Where_Type_Is_A_Generic_Parameter()
{
UsageQueryAggregator agg = new UsageQueryAggregator(
new TypeQuery("BaseLibrary.FieldQuery", "PublicClassWithManyEventsAndMethods"));
TypeDefinition decimalType = TypeQuery.GetTypeByName(TestConstants.MscorlibAssembly, "System.Decimal");
new WhoHasFieldOfType(agg, decimalType);
try
{
agg.Analyze(TestConstants.BaseLibV1Assembly);
Assert.AreEqual(1, agg.FieldMatches.Count, "Field match count");
Assert.AreEqual("myDecimalField", agg.FieldMatches[0].Match.Name, "Field Name");
}
finally
{
if (ExceptionHelper.InException)
{
foreach (var res in agg.FieldMatches)
{
Console.WriteLine("Found field: {0}, file: {1}", res.Match.Print(FieldPrintOptions.All), res.SourceFileName);
}
}
}
}
public async Task <TypeQuery> GetTypeQueryAsync()
{
TypeQuery typeQuery = TypeQuery.empty;
bool filterField = false;
MtdFilter mtdFilter = await GetFilterAsync();
if (mtdFilter != null)
{
filterField = await _context.MtdFilterField.Where(x => x.MtdFilter == mtdFilter.Id).AnyAsync();
if (mtdFilter.SearchNumber != "")
{
typeQuery = TypeQuery.number;
}
if (mtdFilter.SearchNumber == "" && mtdFilter.SearchText != "" && !filterField)
{
typeQuery = TypeQuery.text;
}
if (mtdFilter.SearchNumber == "" && mtdFilter.SearchText == "" && filterField)
{
typeQuery = TypeQuery.field;
}
if (mtdFilter.SearchNumber == "" && mtdFilter.SearchText != "" && filterField)
{
typeQuery = TypeQuery.textField;
}
}
return(typeQuery);
}
public void Can_Query_For_Nested_Type()
{
var query = new TypeQuery("BaseLibrary.TypeQuery", "*NestedClass*");
var nestedTypes = query.GetTypes(TestConstants.BaseLibV1Assembly);
Assert.AreEqual(1, nestedTypes.Count, "Should get nested type.");
}
public void DiffBaseClassAndInmplementedInterfaces()
{
var simpleV1 = TypeQuery.GetTypeByName(TestConstants.BaseLibV1Assembly, "BaseLibrary.TypeDiff.ClassWithInterfacesAndBaseClass");
var simpleV2 = TypeQuery.GetTypeByName(TestConstants.BaseLibV2Assembly, "BaseLibrary.TypeDiff.ClassWithInterfacesAndBaseClass");
TypeDiff diff = TypeDiff.GenerateDiff(simpleV1, simpleV2, myQueries);
try
{
Assert.IsTrue(diff.HasChangedBaseType, "Base class type has changed");
Assert.AreEqual("EventArgs", diff.TypeV1.BaseType.Name, "Base Type V1");
Assert.AreEqual("ResolveEventArgs", diff.TypeV2.BaseType.Name, "Base Type V2");
Assert.AreEqual(2, diff.Interfaces.RemovedCount, "Removed interfaces");
Assert.AreEqual(1, diff.Interfaces.AddedCount, "Added interfaces");
}
finally
{
if (ExceptionHelper.InException)
{
Console.WriteLine("Removed interfaces");
foreach (var remItf in diff.Interfaces.Removed)
{
Console.WriteLine("{0}", remItf.ObjectV1.FullName);
}
Console.WriteLine("Added interfaces");
foreach (var addItf in diff.Interfaces.Added)
{
Console.WriteLine("{0}", addItf.ObjectV1.FullName);
}
}
}
}
public void DiffEvents()
{
var simpleV1 = TypeQuery.GetTypeByName(TestConstants.BaseLibV1Assembly, "BaseLibrary.TypeDiff.EventClass");
var simpleV2 = TypeQuery.GetTypeByName(TestConstants.BaseLibV2Assembly, "BaseLibrary.TypeDiff.EventClass");
TypeDiff diff = TypeDiff.GenerateDiff(simpleV1, simpleV2, myQueries);
try
{
Assert.AreEqual(7, diff.Events.RemovedCount, "Removed events");
Assert.AreEqual(10, diff.Events.AddedCount, "Added events");
}
finally
{
if (ExceptionHelper.InException)
{
Console.WriteLine("Removed events");
foreach (var ev in diff.Events.Removed)
{
Console.WriteLine("{0}", ev.ObjectV1.Print());
}
Console.WriteLine("Added events");
foreach (var ev in diff.Events.Added)
{
Console.WriteLine("{0}", ev.ObjectV1.Print());
}
}
}
}
public void PrintVariousFields()
{
TypeDefinition publicClassWithManyFields = TypeQuery.GetTypeByName(TestConstants.BaseLibV1Assembly, TestConstants.PublicClassWithManyFields);
List <string> myFieldDefinitions = new List <string>
{
"private int privateIntField",
"private List<string> privateListField",
"private const int privateConstant - Value: 9",
"internal readonly int internalReadOnyInt",
"public static readonly int publicReadOnlyStaticint",
"public static int publicStaticIntField",
"public const int publicConstStaticInt - Value: 999",
"protected int protectedIntField",
"protected internal int protectedInternalField",
"protected const int protectedstaticconstField - Value: 879",
"private List<string> privateListField1",
"private List<string> privateListField2",
"protected static readonly int protectedstaticreadonlyField",
"protected internal int protectedInternalField",
"protected internal static int protectedInternalStaticField",
"public static System.DateTime publicStaticDateTimeField",
"protected internal const string protectedInternalConstString - Value: Test Value"
};
foreach (FieldDefinition field in publicClassWithManyFields.Fields)
{
string fieldStr = field.Print(FieldPrintOptions.All);
Console.WriteLine(fieldStr);
Assert.IsTrue(myFieldDefinitions.Contains(fieldStr),
String.Format("Got field string: #{0}# which is not part of required string list", fieldStr));
}
}
public void Should_Get_All_Generic_And_NonGeneric_Types()
{
var query = new TypeQuery(TestConstants.TypeEquivalenceNS, "Class1*");
var genericTypes = query.GetTypes(TestConstants.BaseLibV1Assembly);
Assert.AreEqual(3, genericTypes.Count, "Should get all instances");
}
public void Load_Public_Interfaces_From_Namespace()
{
var query = new TypeQuery(TypeQueryMode.Public | TypeQueryMode.Interface, TypeQueryNS + "*");
List <TypeDefinition> types = query.GetTypes(TestConstants.BaseLibV1Assembly);
Assert.AreEqual(2, types.Count);
}
public void Validate_That_Simple_Method_Calls_From_Local_Variable_Is_Found()
{
TypeDefinition baseClassMethod = TypeQuery.GetTypeByName(TestConstants.BaseLibV1Assembly, "BaseLibrary.ApiChanges.PublicBaseClass");
var baseMethods = MethodQuery.AllMethods.GetMethods(baseClassMethod);
UsageQueryAggregator agg = new UsageQueryAggregator();
new WhoUsesMethod(agg, baseMethods);
try
{
agg.Analyze(TestConstants.DependandLibV1Assembly);
var results = agg.MethodMatches;
Assert.AreEqual(8, results.Count);
}
finally
{
if (ExceptionHelper.InException)
{
foreach (var res in agg.MethodMatches)
{
Console.WriteLine("Got method call at {0} {1} {2}", res.Match.Print(MethodPrintOption.Full),
res.SourceFileName, res.LineNumber);
}
}
agg.Dispose();
}
}
public void Can_Differentiate_Methods_With_GenericParameters()
{
TypeDefinition baseClassMethod = TypeQuery.GetTypeByName(TestConstants.BaseLibV1Assembly, "BaseLibrary.ApiChanges.PublicBaseClass");
var baseMethods = new MethodQuery("public void DoSomeThing(System.Collections.Generic.List<int> l)").GetMethods(baseClassMethod);
Assert.AreEqual(1, baseMethods.Count, "Should get only one method with generic parameter");
UsageQueryAggregator agg = new UsageQueryAggregator();
new WhoUsesMethod(agg, baseMethods);
agg.Analyze(TestConstants.DependandLibV1Assembly);
Assert.AreEqual(2, agg.MethodMatches.Count, "Method match count");
HashSet <string> methods = new HashSet <string>(from m in agg.MethodMatches
select m.Match.Print(MethodPrintOption.Full));
Assert.IsTrue(methods.Contains("public void CallGenericIntFunc(PublicBaseClass cl)"));
var methodWithFloatAsGenericParam = new MethodQuery("public void DoSomeThing(System.Collections.Generic.List<float> l)").GetMethods(baseClassMethod);
Assert.AreEqual(1, methodWithFloatAsGenericParam.Count, "Did not find long function");
agg.Dispose();
agg = new UsageQueryAggregator();
new WhoUsesMethod(agg, methodWithFloatAsGenericParam);
agg.Analyze(TestConstants.DependandLibV1Assembly);
Assert.AreEqual(1, agg.MethodMatches.Count, "Method match count");
Assert.AreEqual("public void CallGenericFloatFunc(PublicBaseClass cl)", agg.MethodMatches[0].Match.Print(MethodPrintOption.Full));
}
public void DiffMethods()
{
var simpleV1 = TypeQuery.GetTypeByName(TestConstants.BaseLibV1Assembly, "BaseLibrary.TypeDiff.MethodClass");
var simpleV2 = TypeQuery.GetTypeByName(TestConstants.BaseLibV2Assembly, "BaseLibrary.TypeDiff.MethodClass");
TypeDiff diff = TypeDiff.GenerateDiff(simpleV1, simpleV2, myQueries);
try
{
Assert.AreEqual(12, diff.Methods.RemovedCount, "Removed methods count");
Assert.AreEqual(7, diff.Methods.AddedCount, "Added methods");
}
finally
{
if (ExceptionHelper.InException)
{
Console.WriteLine("Removed methods");
foreach (var method in diff.Methods.Removed)
{
Console.WriteLine("{0}", method.ObjectV1.Print(MethodPrintOption.Full));
}
Console.WriteLine("Added methods");
foreach (var method in diff.Methods.Added)
{
Console.WriteLine("{0}", method.ObjectV1.Print(MethodPrintOption.Full));
}
}
}
}
public void Load_Internal_Interfaces()
{
TypeQuery query = new TypeQuery(TypeQueryMode.Internal | TypeQueryMode.Interface, TypeQueryNS);
List <TypeDefinition> types = query.GetTypes(TestConstants.BaseLibV1Assembly);
Assert.AreEqual(1, types.Count);
Assert.AreEqual(TestConstants.BaseLibV1Interface1Internal, types[0].FullName);
}
public void DiffBaseClassWithChangeInGenericTypeArgs()
{
var simpleV1 = TypeQuery.GetTypeByName(TestConstants.BaseLibV1Assembly, "BaseLibrary.TypeDiff.ClassWithGenericBase");
var simpleV2 = TypeQuery.GetTypeByName(TestConstants.BaseLibV2Assembly, "BaseLibrary.TypeDiff.ClassWithGenericBase");
TypeDiff diff = TypeDiff.GenerateDiff(simpleV1, simpleV2, myQueries);
Assert.IsTrue(diff.HasChangedBaseType, "Base Type has changed generic argument");
}
public void Can_Find_Reference_Type_Instantiations()
{
UsageQueryAggregator agg = new UsageQueryAggregator(new TypeQuery("DependantLibV1.WhoInstantiatesQueries", "ClassWhichInstantiatesReferenceType"));
new WhoInstantiatesType(agg, TypeQuery.GetTypeByName(TestConstants.BaseLibV1Assembly, "BaseLibrary.ApiChanges.PublicGenericClass`1"));
agg.Analyze(TestConstants.DependandLibV1Assembly);
Assert.AreEqual(1, agg.MethodMatches.Count, "Should get ctor call");
}
public void Load_Public_Interface_With_Exact_Namespace_Match()
{
var query = new TypeQuery(TypeQueryMode.Public | TypeQueryMode.Interface, TypeQueryNS + ".SubNs");
AssemblyDefinition assembly = TestConstants.BaseLibV1Assembly;
List <TypeDefinition> types = query.GetTypes(assembly);
Assert.AreEqual(1, types.Count);
Assert.AreEqual("BaseLibrary.TypeQuery.SubNs.PublicInterfaceInLowerNS", types[0].FullName);
}
public void Can_Find_Value_Type_Instantiations()
{
UsageQueryAggregator agg = new UsageQueryAggregator(new TypeQuery("DependantLibV1.WhoInstantiatesQueries", "ClassWhichInstantiatesValueType"));
new WhoInstantiatesType(agg, TypeQuery.GetTypeByName(TestConstants.MscorlibAssembly, "System.DateTime"));
new WhoInstantiatesType(agg, TypeQuery.GetTypeByName(TestConstants.MscorlibAssembly, "System.Threading.AsyncFlowControl"));
agg.Analyze(TestConstants.DependandLibV1Assembly);
Assert.AreEqual(3, agg.MethodMatches.Count, "Should get ctor call");
}
public void Can_Detect_Enum_Usage_In_Switch_Case()
{
UsageQueryAggregator agg = new UsageQueryAggregator(new TypeQuery("BaseLibrary.TypeUsageQuery", "SwitchOfEnumValues"));
new WhoUsesType(agg, TypeQuery.GetTypeByName(TestConstants.MscorlibAssembly, "System.StringSplitOptions"));
agg.Analyze(TestConstants.BaseLibV1Assembly);
Assert.AreEqual(2, agg.MethodMatches.Count, "method match count");
Assert.AreEqual("UsingSwitchWithEnum", agg.MethodMatches[0].Match.Name);
}
/// <summary>
/// Послать запрос SQL на сервер приложений.
/// </summary>
/// <param name="typeQuery">TypeQuery: Select или Exec</param>
/// <param name="numQuery">Счётчик запросов. Если подключения нет, то устанавливаем автоматически.
/// Этот счётчик, чтобы не зациклиться, если соединение не удалось. Так как процедура вызывается рекурсивно.</param>
/// <param name="sql">Запрос любой, select, update, delete, ddl</param>
/// <param name="ds">System.Data.DataSet</param>
/// <returns>Если успешно, то true</returns>
private bool AppQuery(TypeQuery typeQuery, int numQuery, string sql, out System.Data.DataSet ds)
{
ds = null;
if ((ConnectionGUID == "") || (ServerAppName == ""))
{
sys.SM("Ошибка. соединение с сервером приложений не установлено!");
return(false);
}
CommandCode commandCode = CommandCode.C103;
if (typeQuery == TypeQuery.EXEC)
{
commandCode = CommandCode.C104;
}
string requestStr = sys.ServerAppSendHTTPMessage("Client", ServerAppName, ServerAppPort, commandCode, ConnectionGUID, sql, "", 0);
if (requestStr == "")
{
return(true);
}
if (requestStr.Left(3) == ErrorCode.S501.ToString()) //"501. Ошибка. Сессия с сервером не найдена!")
{
if (numQuery < 2) //Переподключаемся только 1 раз, чтобы не зацикливаться.
{
if (!(sys.Enter(this.ConnectionName, Var.enterMode, Var.UserLogin, Var.UserPass)))
{
sys.SM(requestStr + Var.CR + "Ошибка повторного входа в систему!");
return(false);
}
numQuery = numQuery + 1;
//this.ConnectionGUID = NextConnectionGUID;
//Здесь важно именно писать Var.con.AppQuery, а не просто AppQuery,
//для того, чтобы AppQuery выполнился в другом созданном con,
//для того чтобы использовался ConnectionGUID уже другого con.
//то что SystemEnter возвращает ConnectionGUID ничего не меняет.
//Можно убрать возврат ConnectionGUID из SystemEnter - это ничего не изменит.
Var.con.AppQuery(typeQuery, numQuery, sql, out ds);
return(true);
}
sys.SM(requestStr + Var.CR + "Ошибка подключения к серверу приложений!");
return(false);
}
if (requestStr.Substring(0, 1) == "5")
{
//Все ошибки начинаются на 5:
sys.SM(requestStr);
return(false);
}
ds = sys.StrToDataSet(requestStr);
//LastQueryDateTime = DateTime.Now;
return(true);
}
public void PrintVariousMethods()
{
TypeDefinition classWithMetods = TypeQuery.GetTypeByName(
TestConstants.BaseLibV1Assembly,
"BaseLibrary.Extensions.ClassWithGenericMethodArgs");
foreach (MethodDefinition method in classWithMetods.Methods)
{
Console.WriteLine("{0}", method.Print(MethodPrintOption.Full));
}
}
public void Can_Find_TypeOfAndCast_Calls()
{
UsageQueryAggregator agg = new UsageQueryAggregator(new TypeQuery("DependantLibV1.WhoUsesTypeInSignature", "CastToTypeAndTypeof"));
new WhoUsesType(agg, TypeQuery.GetTypeByName(TestConstants.MscorlibAssembly, "System.IDisposable"));
agg.Analyze(TestConstants.DependandLibV1Assembly);
Assert.AreEqual(2, agg.MethodMatches.Count, "Method match count");
Assert.AreEqual(WhoUsesType.CastReason, agg.MethodMatches[0].Annotations.Reason);
Assert.AreEqual(WhoUsesType.TypeOfReason, agg.MethodMatches[1].Annotations.Reason);
}
public void Can_Detect_Type_Usage_In_Interface()
{
UsageQueryAggregator agg = new UsageQueryAggregator(new TypeQuery("BaseLibrary.TypeUsageQuery", "ITestInterface"));
new WhoUsesType(agg, TypeQuery.GetTypeByName(TestConstants.MscorlibAssembly, "System.String"));
agg.Analyze(TestConstants.BaseLibV1Assembly);
Assert.AreEqual(2, agg.MethodMatches.Count, "Method match count");
Assert.AreEqual(WhoUsesType.UsedAsMethodReturnType, agg.MethodMatches[0].Annotations.Reason);
Assert.AreEqual(WhoUsesType.UsedAsMethodParameterReason, agg.MethodMatches[1].Annotations.Reason);
}
public void Can_Find_Type_As_Field_Type()
{
UsageQueryAggregator agg = new UsageQueryAggregator(new TypeQuery("DependantLibV1.WhoUsesTypeInSignature", "ClassWithSearchedFieldType"));
var charType = TypeQuery.GetTypeByName(TestConstants.MscorlibAssembly, "System.Char");
new WhoUsesType(agg, charType);
agg.Analyze(TestConstants.DependandLibV1Assembly);
Assert.AreEqual(1, agg.FieldMatches.Count, "field match count");
Assert.AreEqual("CharEvent", agg.FieldMatches[0].Match.Name);
}
public void Can_Find_Type_As_Base_Interface()
{
UsageQueryAggregator agg = new UsageQueryAggregator(new TypeQuery("DependantLibV1.WhoUsesTypeInSignature", "ClassImplementsInterface"));
var iDisposable = TypeQuery.GetTypeByName(TestConstants.MscorlibAssembly, "System.IDisposable");
new WhoUsesType(agg, iDisposable);
agg.Analyze(TestConstants.DependandLibV1Assembly);
Assert.AreEqual(1, agg.TypeMatches.Count, "Type match count");
Assert.AreEqual("ClassImplementsInterface", agg.TypeMatches[0].Match.Name);
}
/// <summary>
/// Aggregates the matches from the usage queries.
/// </summary>
/// <param name="bReadPdbs">if set to <c>true</c> [you get file and line information for the matches].</param>
public UsageQueryAggregator(bool bReadPdbs)
{
this.MethodMatches = new List<QueryResult<MethodDefinition>>();
this.TypeMatches = new List<QueryResult<TypeDefinition>>();
this.myTypeQuery = new TypeQuery();
this.FieldMatches = new List<QueryResult<FieldDefinition>>();
this.AssemblyMatches = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
if (bReadPdbs)
{
this.myPdbReader = new PdbInformationReader();
}
}
public List<TypeQuery> GetQueries(string typeQueries, TypeQueryMode additionalFlags)
{
if (typeQueries == null)
{
throw new ArgumentNullException("typeQueries");
}
var trimedQuery = typeQueries.Trim();
if (trimedQuery == "")
{
throw new ArgumentException("typeQueries was an empty string");
}
var queries = trimedQuery.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
var ret = new List<TypeQuery>();
foreach (var query in queries)
{
var m = myQueryParser.Match(query);
if (!m.Success)
{
throw new ArgumentException(string.Format("The type query \"{0}\" is not of the form [public|internal|class|interface|struct|enum|nocompiler|api] typename", query));
}
var mode = this.GetQueryMode(m);
var nameSpaceTypeName = this.SplitNameSpaceAndType(m.Groups["typeName"].Value);
var typeQuery = new TypeQuery(mode, nameSpaceTypeName.Key, nameSpaceTypeName.Value);
if (typeQuery.SearchMode == TypeQueryMode.None)
{
typeQuery.SearchMode |= additionalFlags;
}
ret.Add(typeQuery);
}
return ret;
}
public static Task<IEnumerable<Type>> FindTypes(Assembly assembly, TypeClassification classification, Func<Type, bool> filter = null)
{
var query = new TypeQuery(classification, filter);
return ForAssembly(assembly).ContinueWith(t => query.Find(t.Result));
}
public Query addTypeQuery(TypeQuery type)
{
typeQuery = type;
return this;
}
public UsageQueryAggregator(TypeQuery query) : this(true)
{
this.myTypeQuery = query;
}
