C# IVirtualFile.Open方法代码示例

        MemCachedFile( IVirtualFile file )
        {
            if (file == null) throw new FileNotFoundException();
            this.path = file.VirtualPath;

            using (Stream s = file.Open()) {
                this.data = StreamExtensions.CopyToBytes(s);
            }
        }

 /// <summary>
 /// The write to stream.
 /// </summary>
 /// <param name="provider">
 /// The provider.
 /// </param>
 /// <param name="sw">
 /// The sw.
 /// </param>
 /// <param name="vf">
 /// The vf.
 /// </param>
 /// <param name="type">
 /// The type.
 /// </param>
 /// <param name="origUrl">
 /// The orig url.
 /// </param>
 /// <param name="http">
 /// The http.
 /// </param>
 /// <returns>
 /// The <see cref="bool"/>.
 /// </returns>
 public bool WriteToStream(BaseCompositeFileProcessingProvider provider, StreamWriter sw, IVirtualFile vf, ClientDependencyType type, string origUrl, HttpContextBase http)
 {
     try
     {
         using (var readStream = vf.Open())
         using (var streamReader = new StreamReader(readStream))
         {
             var output = streamReader.ReadToEnd();
             DefaultFileWriter.WriteContentToStream(provider, sw, output, type, http, origUrl);
             return true;
         }
     }
     catch (Exception)
     {
         // the file must have failed to open
         return false;
     }
 }

 /// <summary>
 /// Writes the virtual file to a stream for serving.
 /// </summary>
 /// <param name="provider">The file processing provider.</param>
 /// <param name="streamWriter">The <see cref="StreamWriter"/>.</param>
 /// <param name="virtualFile">The <see cref="IVirtualFile"/> to write.</param>
 /// <param name="type">The <see cref="ClientDependencyType"/> the virtual file matches.</param>
 /// <param name="originalUrl">The original url to the virtual file.</param>
 /// <param name="context">The <see cref="HttpContextBase"/>.</param>
 /// <returns>
 /// The <see cref="bool"/>.
 /// </returns>
 public bool WriteToStream(
     BaseCompositeFileProcessingProvider provider, 
     StreamWriter streamWriter, 
     IVirtualFile virtualFile, 
     ClientDependencyType type, 
     string originalUrl, 
     HttpContextBase context)
 {
     try
     {
         using (Stream readStream = virtualFile.Open())
         using (StreamReader streamReader = new StreamReader(readStream))
         {
             string output = streamReader.ReadToEnd();
             DefaultFileWriter.WriteContentToStream(provider, streamWriter, output, type, context, originalUrl);
             return true;
         }
     }
     catch (Exception)
     {
         // The file must have failed to open
         return false;
     }
 }

 public IVirtualFile GetFileIfCached(string virtualPath, System.Collections.Specialized.NameValueCollection queryString, IVirtualFile original)
 {
     //Use alternate cache key if provided
     string key = original is IVirtualFileSourceCacheKey ? ((IVirtualFileSourceCacheKey)original).GetCacheKey(true) : original.VirtualPath;
     //If cached, serve it.
     CachedVirtualFile c = cache.Get(key);
     if (c != null) return c;
     //If not, let's cache it.
     if ("mem".Equals(queryString["scache"], StringComparison.OrdinalIgnoreCase)) {
         locks.TryExecute(key, 3000, delegate() {
             c = cache.Get(key);
             if (c == null) {
                 using (Stream data = original.Open()) {//Very long-running call
                     c = new CachedVirtualFile(original.VirtualPath, StreamExtensions.CopyToBytes(data, true));
                 }
                 cache.Set(key, c);//Save to cache (may trigger cleanup)
             }
         });
         return c;
     }
     return null;
 }

        public IVirtualFile GetFileIfCached(string virtualPath, System.Collections.Specialized.NameValueCollection queryString, IVirtualFile original)
        {
            if (!"disk".Equals(queryString["scache"], StringComparison.OrdinalIgnoreCase)) return null;

            //Verify web.config exists in the cache folder.
            writer.CheckWebConfigEvery5();

            //Use alternate cache key if provided
            string key = original is IVirtualFileSourceCacheKey ? ((IVirtualFileSourceCacheKey)original).GetCacheKey(false) : original.VirtualPath;
            //If cached, serve it.
            var r = cache.GetCachedFile(key, ".cache", delegate(Stream target)
            {
                using (Stream data = original.Open())
                {//Very long-running call
                    StreamExtensions.CopyToStream(data, target);
                }
            }, DateTime.MinValue, 15 * 1000,true);

            if (r.Result == CacheQueryResult.Failed)
                throw new ImageResizer.ImageProcessingException("Failed to acquire a lock on file \"" + r.PhysicalPath + "\" within 15 seconds. Source caching failed.");

            if (r.Result == CacheQueryResult.Hit && cleaner != null)
                cleaner.UsedFile(r.RelativePath, r.PhysicalPath);

            return new SourceVirtualFile(original.VirtualPath,delegate(){
                return r.Data ?? File.Open(r.PhysicalPath, FileMode.Open, FileAccess.Read, FileShare.Read);
            });
        }

        /// <summary>
        /// Generates the resized image to disk (if needed), then rewrites the request to that location.
        /// Perform 404 checking before calling this method. Assumes file exists.
        /// Called during PostAuthorizeRequest
        /// </summary>
        /// <param name="context"></param>
        /// <param name="virtualPath"></param>
        /// <param name="queryString"></param>
        /// <param name="vf"></param>
        protected virtual void HandleRequest(HttpContext context, string virtualPath, NameValueCollection queryString, IVirtualFile vf)
        {
            Stopwatch s = new Stopwatch();
            s.Start();

            ResizeSettings settings = new ResizeSettings(queryString);

            bool isCaching = settings.Cache == ServerCacheMode.Always;
            bool isProcessing = settings.Process == ProcessWhen.Always;

            //By default, we process it if is both (a) a recognized image extension, and (b) has a resizing directive (not just 'cache').
            if (settings.Process == ProcessWhen.Default){
                //Check for resize directive by removing ('non-resizing' items from the current querystring)
                NameValueCollection copy = new NameValueCollection(queryString);
                copy.Remove("cache"); copy.Remove("process"); copy.Remove("useresizingpipeline"); copy.Remove("404");
                copy.Remove("404.filterMode"); copy.Remove("404.except");
                //If the 'copy' still has directives, and it's an image request, then let's process it.
                isProcessing = conf.IsAcceptedImageType(virtualPath) &&  conf.HasPipelineDirective(copy);
            }

            //By default, we only cache it if we're processing it.
            if (settings.Cache == ServerCacheMode.Default && isProcessing)
                isCaching = true;

            //Resolve the 'cache' setting to 'no' unless we want it cache.
            if (!isCaching) settings.Cache = ServerCacheMode.No;

            //If we are neither processing nor caching, don't do anything more with the request
            if (!isProcessing && !isCaching) return;
            context.Items[conf.ResponseArgsKey] = ""; //We are handling the requests

            //Communicate to the MVC plugin this request should not be affected by the UrlRoutingModule.
            context.Items[conf.StopRoutingKey] = true;

            //Find out if we have a modified date that we can work with
            bool hasModifiedDate = (vf == null) || vf is IVirtualFileWithModifiedDate;
            DateTime modDate = DateTime.MinValue;
            if (hasModifiedDate && vf != null) {
                modDate = ((IVirtualFileWithModifiedDate)vf).ModifiedDateUTC;
                if (modDate == DateTime.MinValue || modDate == DateTime.MaxValue) {
                    hasModifiedDate = false; //Skip modified date checking if the file has no modified date
                }
            }

            IEncoder guessedEncoder = null;
            //Only use an encoder to determine extension/mime-type when it's an image extension or when we've set process = always.
            if (isProcessing) {
                guessedEncoder = conf.GetImageBuilder().EncoderProvider.GetEncoder(settings, virtualPath);
                if (guessedEncoder == null) throw new ImageProcessingException("Image Resizer: No image encoder was found for the request.");
            }

            //Determine the file extenson for the caching system to use if we aren't processing the image
            //Use the exsiting one if is an image extension. If not, use "unknown".
            // We don't want to suggest writing .exe or .aspx files to the cache!
            string fallbackExtension = PathUtils.GetFullExtension(virtualPath).TrimStart('.');
            if (!conf.IsAcceptedImageType(virtualPath)) fallbackExtension = "unknown";

            //Determine the mime-type if we aren't processing the image.
            string fallbackContentType = "application/octet-stream";
            //Support jpeg, png, gif, bmp, tiff mime-types. Otherwise use "application/octet-stream".
            //We can't set it to null - it will default to text/html
            System.Drawing.Imaging.ImageFormat recognizedExtension = DefaultEncoder.GetImageFormatFromExtension(fallbackExtension);
            if (recognizedExtension != null) fallbackContentType = DefaultEncoder.GetContentTypeFromImageFormat(recognizedExtension);

            //Build CacheEventArgs
            ResponseArgs e = new ResponseArgs();
            e.RequestKey = virtualPath + PathUtils.BuildQueryString(queryString);
            e.RewrittenQuerystring = settings;
            e.ResponseHeaders.ContentType = isProcessing ? guessedEncoder.MimeType : fallbackContentType;
            e.SuggestedExtension = isProcessing ? guessedEncoder.Extension : fallbackExtension;
            e.HasModifiedDate = hasModifiedDate;
            //Add delegate for retrieving the modified date of the source file.
            e.GetModifiedDateUTC = new ModifiedDateDelegate(delegate() {
                if (vf == null)
                    return System.IO.File.GetLastWriteTimeUtc(HostingEnvironment.MapPath(virtualPath));
                else if (hasModifiedDate)
                    return modDate;
                else return DateTime.MinValue; //Won't be called, no modified date available.
            });

            //A delegate for accessing the source file
            e.GetSourceImage = new GetSourceImageDelegate(delegate() {
                return (vf != null) ? vf.Open() : File.Open(HostingEnvironment.MapPath(virtualPath), FileMode.Open, FileAccess.Read, FileShare.Read);
            });

            //Add delegate for writing the data stream
            e.ResizeImageToStream = new ResizeImageDelegate(delegate(System.IO.Stream stream) {
                //This runs on a cache miss or cache invalid. This delegate is preventing from running in more
                //than one thread at a time for the specified cache key
                try {
                    if (!isProcessing) {
//.........这里部分代码省略.........