C# Analyzer.Analyze方法代码示例

        public override void Initialize(AnalysisContext analysisContext)
        {
            // this is stateless analyzer, can run concurrently
            analysisContext.EnableConcurrentExecution();

            // this has no meaning on running on generated code which user can't control
            analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);

            analysisContext.RegisterCompilationStartAction(c =>
            {
                INamedTypeSymbol @string = WellKnownTypes.String(c.Compilation);
                INamedTypeSymbol uri = WellKnownTypes.Uri(c.Compilation);
                if (@string == null || uri == null)
                {
                    // we don't have required types
                    return;
                }

                var analyzer = new Analyzer(c.Compilation, @string, uri, GetInvocationExpression);

                // REVIEW: I need to do this thing because OperationAnalysisContext doesn't give me OwningSymbol
                c.RegisterOperationBlockStartAction(sc =>
                {
                    sc.RegisterOperationAction(oc => analyzer.Analyze(oc, sc.OwningSymbol), OperationKind.InvocationExpression);
                });
            });
        }

    public static void Main(String[] args)
    {
        try
        {
            ITransformer transformer = new Transformer();
            IReader reader = new ConsoleReader();
            IAnalyzer analyzer = new Analyzer(reader, transformer);
            AnalysisResult analysisResult = analyzer.Analyze();
            IDumper fileDumper = new ConsoleDumper(analysisResult);

            // A better way to inform about the result would be an Enum with some codes (error dumping, error reading, error connecting to db, etc)
            bool operationFinished = fileDumper.Dump();
            string message = "";
            if (operationFinished) { message = ""; }
            else { message = "The application encountered an error. Please check the logs. Press Enter to exit."; }

            Console.WriteLine(message);
            Console.ReadLine();
        }
        catch (Exception ex)
        {
            ex.Log("");
            Console.WriteLine("The application encountered an error. Please check the logs. Press Enter to exit.");
            Console.ReadLine();
        }
    }

        public BuildResult Apply(IDictionary<string, string> substitutions, bool debug)
        {
            var analyzer = new Analyzer(script.Compilation, substitutions);
            var analyzed = analyzer.Analyze();

            var rewriter = new Rewriter(script.Compilation, analyzed);
            var rewritten = rewriter.Rewrite();

            byte[] assembly;
            byte[] symbols = null;

            if (debug)
                EmitDebug(rewritten, out assembly, out symbols);
            else
                Emit(rewritten, out assembly);

            return new BuildResult(
                analyzed.Tasks.ToArray(),
                script.References.ToArray(),
                rewriter.Captured.ToArray(),
                assembly, symbols
            );
        }

		/// <summary>
		/// Compiles the transient unit. 'PreCompile' should be called first!
		/// </summary>
		internal bool Compile(CompilationContext/*!*/ context, EvalKinds kind)
		{
			Analyzer analyzer = null;

			try
			{
				analyzer = new Analyzer(context);

				// perform pre-analysis on types and functions:
				if (types != null)
					analyzer.PreAnalyze(types.Values);

				if (functions != null)
					analyzer.PreAnalyze(functions.Values);

				// perform member analysis on types and functions:
				if (types != null)
					analyzer.AnalyzeMembers(types.Values);
				if (functions != null)
					analyzer.AnalyzeMembers(functions.Values);
				
				if (context.Errors.AnyFatalError) return false;

				// perform full analysis:
				analyzer.Analyze(sourceUnit);

				if (context.Errors.AnyFatalError) return false;

				// perform post analysis:
				analyzer.PostAnalyze();
			}
			catch (CompilerException)
			{
				return false;
			}
			finally
			{
				resolvingScriptContext = null;
				referringType = null;
			}

			// do not emit anything if there was parse/analysis error:
			if (context.Errors.AnyError) return false;

			DefineBuilders();

			// define constructed types:
			analyzer.DefineConstructedTypeBuilders();

			CodeGenerator cg = new CodeGenerator(context);
			sourceUnit.Emit(cg);
			return true;
		}