private Tuple <Type, CompilationData> CompileTypeImpl(TypeContext context)
        {
            var result        = Compile(context);
            var compileResult = result.Item1;

            CompilationData tmpDir;

            if (compileResult.TempFiles != null)
            {
                tmpDir = new CompilationData(result.Item2, compileResult.TempFiles.TempDir);
            }
            else
            {
                tmpDir = new CompilationData(result.Item2, null);
            }

            if (compileResult.Errors != null && compileResult.Errors.HasErrors)
            {
                throw new TemplateCompilationException(
                          compileResult.Errors
                          .Cast <CompilerError>()
                          .Select(error =>
                                  new RazorEngineCompilerError(
                                      error.ErrorText,
                                      error.FileName,
                                      error.Line,
                                      error.Column,
                                      error.ErrorNumber,
                                      error.IsWarning)),
                          tmpDir, context.TemplateContent);
            }
            // Make sure we load the assembly from a file and not with
            // Load(byte[]) (or it will be fully trusted!)
            var assemblyPath = compileResult.PathToAssembly;

            if (DisableTempFileLocking)
            {
                compileResult.CompiledAssembly = Assembly.Load(File.ReadAllBytes(assemblyPath));
            }
            else
            {
                compileResult.CompiledAssembly = Assembly.LoadFile(assemblyPath);
            }
            var type = compileResult.CompiledAssembly.GetType(DynamicTemplateNamespace + "." + context.ClassName);

            if (type == null)
            {
                try
                {
                    compileResult.CompiledAssembly.GetTypes();
                }
                catch (Exception e)
                {
                    throw new TemplateLoadingException("Unable to load types of the laded assembly", e);
                }
                // if we are here we just throw
                throw new TemplateLoadingException("We could not find the type in the compiled assembly!");
            }
            return(Tuple.Create(type, tmpDir));
        }
 /// <summary>
 /// Initialises a new instance of <see cref="TemplateCompilationException"/>.
 /// </summary>
 /// <param name="errors">The set of compiler errors.</param>
 /// <param name="files">The source code that wasn't compiled.</param>
 /// <param name="template">The source template that wasn't compiled.</param>
 public TemplateCompilationException(IEnumerable<RazorEngineCompilerError> errors, CompilationData files, ITemplateSource template)
     : base(TemplateCompilationException.GetMessage(errors, files, template))
 {
     var list = errors.ToList();
     CompilerErrors = new ReadOnlyCollection<RazorEngineCompilerError>(list);
     CompilationData = files;
     Template = template.Template;
 }
 public CompiledTemplate(CompilationData tempFiles, ITemplateKey key, ITemplateSource source, Type templateType, Type modelType)
 {
     _tempFiles = tempFiles;
     _key = key;
     _source = source;
     _templateType = templateType;
     _modelType = modelType;
 }
        /// <summary>
        /// Gets a exact error message of the given error collection
        /// </summary>
        /// <param name="errors"></param>
        /// <param name="files"></param>
        /// <param name="template"></param>
        /// <returns></returns>
        internal static string GetMessage(IEnumerable<RazorEngineCompilerError> errors, CompilationData files, ITemplateSource template)
        {
            var errorMsgs = string.Join("\n\t", errors.Select(error =>
                string.Format(
                    " - {0}: ({1}, {2}) {3}", 
                    error.IsWarning ? "warning" : "error", 
                    error.Line, error.Column, error.ErrorText)));

            const string rawTemplateFileMsg = "The template-file we tried to compile is: {0}\n";
            const string rawTemplate = "The template we tried to compile is: {0}\n";
            const string rawTmpFiles = "Temporary files of the compilation can be found in (please delete the folder): {0}\n";
            const string rawSourceCode = "The generated source code is: {0}\n";

            string templateFileMsg;
            if (string.IsNullOrEmpty(template.TemplateFile)) {
                templateFileMsg = string.Format(rawTemplate, Separate(template.Template ?? string.Empty));
	        } else{
                templateFileMsg = string.Format(rawTemplateFileMsg, template.TemplateFile ?? string.Empty);
            }
            string tempFilesMsg = string.Empty;
            if (files.TmpFolder != null)
            {
                tempFilesMsg = string.Format(rawTmpFiles, files.TmpFolder);
            }

            string sourceCodeMessage = string.Empty;
            if (files.SourceCode != null)
            {
                sourceCodeMessage = string.Format(rawSourceCode, Separate(files.SourceCode));
            }

            string loadedAssemblies =
                "\nList of loaded Assemblies:\n" +
                string.Join("\n\tLoaded Assembly: ",
                    (new Compilation.ReferenceResolver.UseCurrentAssembliesReferenceResolver())
                    .GetReferences().Select(r => r.GetFile()));

            var rawMessage = @"Errors while compiling a Template.
Please try the following to solve the situation:
  * If the problem is about missing/invalid references or multiple defines either try to load 
    the missing references manually (in the compiling appdomain!) or
    Specify your references manually by providing your own IReferenceResolver implementation.
    See https://antaris.github.io/RazorEngine/ReferenceResolver.html for details.
    Currently all references have to be available as files!
  * If you get 'class' does not contain a definition for 'member': 
        try another modelType (for example 'null' to make the model dynamic).
        NOTE: You CANNOT use typeof(dynamic) to make the model dynamic!
    Or try to use static instead of anonymous/dynamic types.
More details about the error:
{0}
{1}{2}{3}{4}";
            return string.Format(rawMessage, errorMsgs, tempFilesMsg, templateFileMsg, sourceCodeMessage, loadedAssemblies);
        }
        public override Tuple <Type, CompilationData> CompileType(TypeContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            (new PermissionSet(PermissionState.Unrestricted)).Assert();
            var result        = Compile(context);
            var compileResult = result.Item1;

            CompilationData tmpDir;

            if (compileResult.TempFiles != null)
            {
                tmpDir = new CompilationData(result.Item2, compileResult.TempFiles.TempDir);
            }
            else
            {
                tmpDir = new CompilationData(result.Item2, null);
            }

            if (compileResult.Errors != null && compileResult.Errors.HasErrors)
            {
                throw new TemplateCompilationException(
                          compileResult.Errors
                          .Cast <CompilerError>()
                          .Select(error =>
                                  new RazorEngineCompilerError(
                                      error.ErrorText,
                                      error.FileName,
                                      error.Line,
                                      error.Column,
                                      error.ErrorNumber,
                                      error.IsWarning)),
                          tmpDir, context.TemplateContent);
            }
            // Make sure we load the assembly from a file and not with
            // Load(byte[]) (or it will be fully trusted!)
            var assemblyPath = compileResult.PathToAssembly;

            compileResult.CompiledAssembly = Assembly.LoadFile(assemblyPath);
            var type = compileResult.CompiledAssembly.GetType(DynamicTemplateNamespace + "." + context.ClassName);

            return(Tuple.Create(type, tmpDir));
        }
        /// <summary>
        /// Initialises a new instance of <see cref="TemplateCompilationException"/> from serialised data.
        /// </summary>
        /// <param name="info">The serialisation info.</param>
        /// <param name="context">The streaming context.</param>
        protected TemplateCompilationException(SerializationInfo info, StreamingContext context) : base(info, context)
        {
            int count = info.GetInt32("Count");

            var list = new List<RazorEngineCompilerError>();
            var type = typeof(RazorEngineCompilerError);

            for (int i = 0; i < count; i++)
            {
                list.Add((RazorEngineCompilerError)info.GetValue("CompilerErrors[" + i + "]", type));
            }

            CompilerErrors = new ReadOnlyCollection<RazorEngineCompilerError>(list);
            var sourceCode = info.GetString("SourceCode");
            if (string.IsNullOrEmpty(sourceCode))
            {
                sourceCode = null;
            }
            var tmpFolder = info.GetString("TmpFolder");
            if (string.IsNullOrEmpty(tmpFolder))
            {
                tmpFolder = null;
            }
            CompilationData = new CompilationData(sourceCode, tmpFolder);
            Template = info.GetString("Template");
        }
        private Tuple<Type, CompilationData> CompileTypeImpl(TypeContext context)
        {
            var result = Compile(context);
            var compileResult = result.Item1;

            CompilationData tmpDir;
            if (compileResult.TempFiles != null)
            {
                tmpDir = new CompilationData(result.Item2, compileResult.TempFiles.TempDir);
            }
            else
            {
                tmpDir = new CompilationData(result.Item2, null);
            }

            if (compileResult.Errors != null && compileResult.Errors.HasErrors)
            {
                throw new TemplateCompilationException(
                    compileResult.Errors
                    .Cast<CompilerError>()
                    .Select(error =>
                        new RazorEngineCompilerError(
                            error.ErrorText,
                            error.FileName,
                            error.Line,
                            error.Column,
                            error.ErrorNumber,
                            error.IsWarning)),
                    tmpDir, context.TemplateContent);
            }
            // Make sure we load the assembly from a file and not with
            // Load(byte[]) (or it will be fully trusted!)
            var assemblyPath = compileResult.PathToAssembly;
            if (DisableTempFileLocking)
            {
                compileResult.CompiledAssembly = Assembly.Load(File.ReadAllBytes(assemblyPath));
            }
            else
            {
                compileResult.CompiledAssembly = Assembly.LoadFile(assemblyPath);
            }
            var type = compileResult.CompiledAssembly.GetType(DynamicTemplateNamespace + "." + context.ClassName);
            if (type == null)
            {
                try
                {
                    compileResult.CompiledAssembly.GetTypes();
                }
                catch (Exception e)
                {
                    throw new TemplateLoadingException("Unable to load types of the laded assembly", e);
                }
                // if we are here we just throw
                throw new TemplateLoadingException("We could not find the type in the compiled assembly!");
            }
            return Tuple.Create(type, tmpDir);
        }
        public override Tuple<Type, CompilationData> CompileType(TypeContext context)
        {
            if (context == null)
                throw new ArgumentNullException("context");

            (new PermissionSet(PermissionState.Unrestricted)).Assert();
            var result = Compile(context);
            var compileResult = result.Item1;

            CompilationData tmpDir;
            if (compileResult.TempFiles != null)
            {
                tmpDir = new CompilationData(result.Item2, compileResult.TempFiles.TempDir);
            }
            else
            {
                tmpDir = new CompilationData(result.Item2, null);
            }

            if (compileResult.Errors != null && compileResult.Errors.HasErrors)
            {
                throw new TemplateCompilationException(
                    compileResult.Errors
                    .Cast<CompilerError>()
                    .Select(error =>
                        new RazorEngineCompilerError(
                            error.ErrorText,
                            error.FileName,
                            error.Line,
                            error.Column,
                            error.ErrorNumber,
                            error.IsWarning)),
                    tmpDir, context.TemplateContent);
            }
            // Make sure we load the assembly from a file and not with
            // Load(byte[]) (or it will be fully trusted!)
            var assemblyPath = compileResult.PathToAssembly;
            compileResult.CompiledAssembly = Assembly.LoadFile(assemblyPath);
            var type = compileResult.CompiledAssembly.GetType(DynamicTemplateNamespace + "." + context.ClassName);
            return Tuple.Create(type, tmpDir);
        }