internal Type GetReferencedType(VirtualPath virtualPath, bool allowNoCompile)
        {
            virtualPath = base.ResolveVirtualPath(virtualPath);
            if ((base._pageParserFilter != null) && !base._pageParserFilter.AllowVirtualReference(base.CompConfig, virtualPath))
            {
                base.ProcessError(System.Web.SR.GetString("Reference_not_allowed", new object[] { virtualPath }));
            }
            BuildResult vPathBuildResult = null;
            Type        baseType         = null;

            try
            {
                vPathBuildResult = BuildManager.GetVPathBuildResult(virtualPath);
            }
            catch (HttpCompileException exception)
            {
                if (exception.VirtualPathDependencies != null)
                {
                    foreach (string str in exception.VirtualPathDependencies)
                    {
                        base.AddSourceDependency(VirtualPath.Create(str));
                    }
                }
                throw;
            }
            catch
            {
                if (this.IgnoreParseErrors)
                {
                    base.AddSourceDependency(virtualPath);
                }
                throw;
            }
            BuildResultNoCompileTemplateControl control = vPathBuildResult as BuildResultNoCompileTemplateControl;

            if (control != null)
            {
                if (!allowNoCompile)
                {
                    return(null);
                }
                baseType = control.BaseType;
            }
            else
            {
                if (!(vPathBuildResult is BuildResultCompiledType))
                {
                    throw new HttpException(System.Web.SR.GetString("Invalid_typeless_reference", new object[] { "src" }));
                }
                BuildResultCompiledType type2 = (BuildResultCompiledType)vPathBuildResult;
                baseType = type2.ResultType;
            }
            base.AddTypeDependency(baseType);
            base.AddBuildResultDependency(vPathBuildResult);
            return(baseType);
        }
Exemplo n.º 2
0
 internal void SetNoCompileBuildResult(BuildResultNoCompileTemplateControl noCompileBuildResult)
 {
     this._noCompileBuildResult = noCompileBuildResult;
 }
        internal Type GetReferencedType(VirtualPath virtualPath, bool allowNoCompile)
        {
            virtualPath = ResolveVirtualPath(virtualPath);

            // If we have a page parser filter, make sure the reference is allowed
            if (_pageParserFilter != null && !_pageParserFilter.AllowVirtualReference(CompConfig, virtualPath))
            {
                ProcessError(SR.GetString(SR.Reference_not_allowed, virtualPath));
            }

            BuildResult result = null;
            Type        t      = null;

            try {
                result = BuildManager.GetVPathBuildResult(virtualPath);
            }
            catch (HttpCompileException e) {
                // Add the path depdencies properly so we know when
                // to invalidate the cached result.
                if (e.VirtualPathDependencies != null)
                {
                    foreach (string vPath in e.VirtualPathDependencies)
                    {
                        AddSourceDependency(VirtualPath.Create(vPath));
                    }
                }

                throw;
            }
            catch {
                // Add the virtualPath to the dependency so that
                // we know when to check again. This could happen if the
                // virtualPath points to a file not created yet.
                // This only affects designtime code path since we do want to return
                // partial result even if there is an error, and that result is
                // cached. VSWhidbey 372585
                if (IgnoreParseErrors)
                {
                    AddSourceDependency(virtualPath);
                }

                throw;
            }

            // Is it a no-compile page/uc
            BuildResultNoCompileTemplateControl noCompileResult = result as BuildResultNoCompileTemplateControl;

            if (noCompileResult != null)
            {
                // If no-compile is not acceptable, return null
                if (!allowNoCompile)
                {
                    return(null);
                }

                // In the no-compile case, use the base type, since we don't compile a type
                t = noCompileResult.BaseType;
            }
            else if (result is BuildResultCompiledType)
            {
                BuildResultCompiledType compiledResult = (BuildResultCompiledType)result;
                Debug.Assert(compiledResult != null);

                t = compiledResult.ResultType;
            }
            else
            {
                throw new HttpException(SR.GetString(SR.Invalid_typeless_reference, _sourceString));
            }

            Debug.Assert(t != null);

            // Add a dependency on the Type
            AddTypeDependency(t);

            // Add a dependency on the BuildResult
            AddBuildResultDependency(result);

            return(t);
        }