C# ClientDependencyType.ToString方法代码示例

 /// <summary>
 /// Returns the url for the composite file handler for the filePath specified.
 /// </summary>
 /// <param name="filePaths"></param>
 /// <param name="type"></param>
 /// <param name="http"></param>
 /// <returns></returns>
 public static string GetCompositeFileUrl(string filePaths, ClientDependencyType type, HttpContextBase http)
 {
     //build the combined composite list url
     string handler = "{0}?s={1}&t={2}";
     string combinedurl = string.Format(handler, ClientDependencySettings.Instance.CompositeFileHandlerPath, http.Server.UrlEncode(EncodeTo64(filePaths)), type.ToString());
     return combinedurl;
 }

		/// <summary>
		/// Saves the file's bytes to disk with a hash of the byte array
		/// </summary>
		/// <param name="fileContents"></param>
		/// <param name="type"></param>
		/// <returns>The new file path</returns>
		/// <remarks>
		/// the extension will be: .cdj for JavaScript and .cdc for CSS
		/// </remarks>
		public static string SaveCompositeFile(byte[] fileContents, ClientDependencyType type)
		{
            //don't save the file if composite files are disabled.
            if (!ClientDependencySettings.Instance.EnableCompositeFiles)
                return string.Empty;

			if (!ClientDependencySettings.Instance.CompositeFilePath.Exists)
				ClientDependencySettings.Instance.CompositeFilePath.Create();
			FileInfo fi = new FileInfo(
				Path.Combine(ClientDependencySettings.Instance.CompositeFilePath.FullName,
					fileContents.GetHashCode().ToString() + ".cd" + type.ToString().Substring(0, 1).ToLower()));
			if (fi.Exists)
				fi.Delete();
			FileStream fs = fi.Create();
			fs.Write(fileContents, 0, fileContents.Length);
			fs.Close();
			return fi.FullName;
		}

	    /// <summary>
	    /// Saves the file's bytes to disk with a hash of the byte array
	    /// </summary>
	    /// <param name="fileContents"></param>
	    /// <param name="type"></param>
	    /// <param name="server"></param>
	    /// <returns>The new file path</returns>
	    /// <remarks>
	    /// the extension will be: .cdj for JavaScript and .cdc for CSS
	    /// </remarks>
	    public override FileInfo SaveCompositeFile(byte[] fileContents, ClientDependencyType type, HttpServerUtilityBase server, int version)
		{
            //don't save the file if composite files are disabled.
            if (!PersistCompositeFiles)
                return null;

            if (!CompositeFilePath.Exists)
                CompositeFilePath.Create();
			
            var fi = new FileInfo(
                Path.Combine(CompositeFilePath.FullName,
					version + "_" + Guid.NewGuid().ToString("N") + ".cd" + type.ToString().Substring(0, 1).ToUpper()));
			
            if (fi.Exists)
				fi.Delete();
			
            var fs = fi.Create();
			fs.Write(fileContents, 0, fileContents.Length);
			fs.Close();
			return fi;
		}

        /// <summary>
        /// Returns a URL used to return a compbined/compressed/optimized version of all dependencies.
        /// <remarks>
        /// The full url with the encoded query strings for the handler which will process the composite list
        /// of dependencies. The handler will compbine, compress, minify, and output cache the results
        /// on the base64 encoded string.
        /// </remarks>        
        /// </summary>
        /// <param name="dependencies"></param>
        /// <param name="type"></param>
        /// <param name="http"></param>
        /// <returns>An array containing the list of composite file URLs. This will generally only contain 1 value unless
        /// the number of files registered exceeds the maximum length, then it will return more than one file.</returns>
        public virtual string[] ProcessCompositeList(
            IEnumerable<IClientDependencyFile> dependencies, 
            ClientDependencyType type, 
            HttpContextBase http)
        {
            if (!dependencies.Any())
                return new string[] { };

            switch (UrlType)
            {
                case CompositeUrlType.MappedId:
                    
                    //use the file mapper to create us a file key/id for the file set
                    var fileKey = ClientDependencySettings.Instance.DefaultFileMapProvider.CreateNewMap(http, dependencies, GetVersion());

                    //create the url
                    return new[] { GetCompositeFileUrl(fileKey, type, http, CompositeUrlType.MappedId) };

                default:
                    
                    //build the combined composite list urls          
                    
                    var files = new List<string>();
                    var currBuilder = new StringBuilder();
                    var base64Builder = new StringBuilder();
                    var builderCount = 1;
                    var stringType = type.ToString();
                    foreach (var a in dependencies)
                    {
                        //update the base64 output to get the length
                        base64Builder.Append(a.FilePath.EncodeTo64());

                        //test if the current base64 string exceeds the max length, if so we need to split
                        if ((base64Builder.Length + ClientDependencySettings.Instance.CompositeFileHandlerPath.Length + stringType.Length + 10) 
                            >= (CompositeDependencyHandler.MaxHandlerUrlLength))
                        {
                            //add the current output to the array
                            files.Add(currBuilder.ToString());
                            //create some new output
                            currBuilder = new StringBuilder();
                            base64Builder = new StringBuilder();
                            builderCount++;
                        }

                        //update the normal builder
                        currBuilder.Append(a.FilePath + ";");
                    }

                    if (builderCount > files.Count)
                    {
                        files.Add(currBuilder.ToString());
                    }

                    //now, compress each url
                    for (var i = 0; i < files.Count; i++)
                    {
                        //append our version to the combined url 
                        var encodedFile = files[i].EncodeTo64Url();
                        files[i] = GetCompositeFileUrl(encodedFile, type, http, UrlType);
                    }

                    return files.ToArray();
            }            
        }

        /// <summary>
        /// When the path type is one of the base64 paths, this will create the composite file urls for all of the dependencies. 
        /// </summary>
        /// <param name="type"></param>
        /// <param name="dependencies"></param>
        /// <param name="compositeFileHandlerPath"></param>
        /// <param name="http"></param>
        /// <param name="maxLength">the max length each url can be</param>
        /// <param name="version">the current cdf version</param>
        /// <returns></returns>
        /// <remarks>
        /// Generally there will only be one path returned but his depends on how many dependencies there are and whether the base64 created path will exceed the max url length parameter.
        /// If the string length exceeds it, then we need to creaet multiple paths all of which must be less length than the maximum provided.
        /// </remarks>
        internal IEnumerable<string> GetCompositeFileUrls(
            ClientDependencyType type,
            IClientDependencyFile[] dependencies,
            string compositeFileHandlerPath,
            HttpContextBase http,
            int maxLength,
            int version)
        {
            var files = new List<string>();
            var currBuilder = new StringBuilder();
            var base64Builder = new StringBuilder();
            var builderCount = 1;
            var stringType = type.ToString();

            var remaining = new Queue<IClientDependencyFile>(dependencies);
            while (remaining.Any())
            {
                var current = remaining.Peek();

                //update the base64 output to get the length
                base64Builder.Append(current.FilePath.EncodeTo64());

                //test if the current base64 string exceeds the max length, if so we need to split
                if ((base64Builder.Length
                     + compositeFileHandlerPath.Length
                     + stringType.Length
                     + version.ToString(CultureInfo.InvariantCulture).Length
                    //this number deals with the ampersands, etc...
                     + 10)
                    >= (maxLength))
                {
                    //we need to do a check here, this is the first one and it's already exceeded the max length we cannot continue
                    if (currBuilder.Length == 0)
                    {
                        throw new InvalidOperationException("The path for the single dependency: '" + current.FilePath + "' exceeds the max length (" + maxLength + "), either reduce the single dependency's path length or increase the CompositeDependencyHandler.MaxHandlerUrlLength value");
                    }

                    //flush the current output to the array
                    files.Add(currBuilder.ToString());
                    //create some new output
                    currBuilder = new StringBuilder();
                    base64Builder = new StringBuilder();
                    builderCount++;
                }
                else
                {
                    //update the normal builder
                    currBuilder.Append(current.FilePath + ";");
                    //remove from the queue
                    remaining.Dequeue();
                }
            }

            //foreach (var a in dependencies)
            //{
            //    //update the base64 output to get the length
            //    base64Builder.Append(a.FilePath.EncodeTo64());

            //    //test if the current base64 string exceeds the max length, if so we need to split
            //    if ((base64Builder.Length
            //        + compositeFileHandlerPath.Length
            //        + stringType.Length
            //        + version.Length
            //        + 10)
            //        >= (maxLength))
            //    {
            //        //add the current output to the array
            //        files.Add(currBuilder.ToString());
            //        //create some new output
            //        currBuilder = new StringBuilder();
            //        base64Builder = new StringBuilder();
            //        builderCount++;
            //    }

            //    //update the normal builder
            //    currBuilder.Append(a.FilePath + ";");
            //}

            if (builderCount > files.Count)
            {
                files.Add(currBuilder.ToString());
            }

            //now, compress each url
            for (var i = 0; i < files.Count; i++)
            {
//.........这里部分代码省略.........

        /// <summary>
        /// Returns a URL used to return a compbined/compressed/optimized version of all dependencies.
        /// <remarks>
        /// The full url with the encoded query strings for the handler which will process the composite list
        /// of dependencies. The handler will compbine, compress, minify, and output cache the results
        /// on the base64 encoded string.
        /// </remarks>        
        /// </summary>
        /// <param name="dependencies"></param>
        /// <param name="type"></param>
        /// <param name="http"></param>
        /// <returns>An array containing the list of composite file URLs. This will generally only contain 1 value unless
        /// the number of files registered exceeds the maximum length, then it will return more than one file.</returns>
        public string[] ProcessCompositeList(List<IClientDependencyFile> dependencies, ClientDependencyType type, HttpContextBase http)
        {
            if (dependencies.Count == 0)
                return new string[] { };

            //build the combined composite list urls
            var files = new List<string>();
            var currBuilder = new StringBuilder();
            var builderCount = 1;
            var stringType = type.ToString();
            foreach (var a in dependencies)
            {
                //if the addition of this file is going to exceed 75% of the max length (since we'll be base64 encoding), we'll need to split
                if ((currBuilder.Length +
                    a.FilePath.Length +
                    ClientDependencySettings.Instance.CompositeFileHandlerPath.Length +
                    stringType.Length + 10) >= (CompositeDependencyHandler.MaxHandlerUrlLength * 0.75))
                {
                    //add the current output to the array
                    files.Add(currBuilder.ToString());
                    //create some new output
                    currBuilder = new StringBuilder();
                    builderCount++;
                }

                currBuilder.Append(a.FilePath + ";");
            }

            if (builderCount > files.Count)
            {
                files.Add(currBuilder.ToString());
            }

            //now, compress each url
            for (var i = 0; i < files.Count; i++)
            {
                //append our version to the combined url
                files[i] = AppendVersionQueryString(GetCompositeFileUrl(files[i], type, http));
            }

            return files.ToArray();
        }