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; }