caractères ajouté au début de chaque fichier
J'ai téléchargé un HttpHandler classe qui concatène les fichiers JS dans un fichier et il garde en lui ajoutant les 
caractères au début de chaque fichier, il concatène.
Toutes les idées sur ce qui en est la cause? Se pourrait-il qu'ignorer les fichiers traités, ils sont écrites dans le cache et c'est ainsi que le cache de stockage/de rendu?
Toutes les entrées seraient grandement appréciés.
using System;
using System.Net;
using System.IO;
using System.IO.Compression;
using System.Text;
using System.Configuration;
using System.Web;
public class HttpCombiner : IHttpHandler {
private const bool DO_GZIP = false;
private readonly static TimeSpan CACHE_DURATION = TimeSpan.FromDays(30);
public void ProcessRequest (HttpContext context) {
HttpRequest request = context.Request;
//Read setName, contentType and version. All are required. They are
//used as cache key
string setName = request["s"] ?? string.Empty;
string contentType = request["t"] ?? string.Empty;
string version = request["v"] ?? string.Empty;
//Decide if browser supports compressed response
bool isCompressed = DO_GZIP && this.CanGZip(context.Request);
//Response is written as UTF8 encoding. If you are using languages
//like Arabic, you should change this to proper encoding
UTF8Encoding encoding = new UTF8Encoding(false);
//If the set has already been cached, write the response directly
//from cache. Otherwise generate the response and cache it
if (!this.WriteFromCache(context, setName, version, isCompressed,
contentType))
{
using (MemoryStream memoryStream = new MemoryStream(5000))
{
//Decide regular stream or GZipStream based on whether the
//response can be cached or not
using (Stream writer = isCompressed
? (Stream)(new GZipStream(memoryStream,
CompressionMode.Compress))
: memoryStream)
{
//Load the files defined in <appSettings> and process
//each file
string setDefinition = System.Configuration
.ConfigurationManager.AppSettings[setName] ?? "";
string[] fileNames = setDefinition.Split(
new char[] { ',' },
StringSplitOptions.RemoveEmptyEntries);
foreach (string fileName in fileNames)
{
byte[] fileBytes = this.GetFileBytes(
context, fileName.Trim(), encoding);
writer.Write(fileBytes, 0, fileBytes.Length);
}
writer.Close();
}
//Cache the combined response so that it can be directly
//written in subsequent calls
byte[] responseBytes = memoryStream.ToArray();
context.Cache.Insert(
GetCacheKey(setName, version, isCompressed),
responseBytes, null,
System.Web.Caching.Cache.NoAbsoluteExpiration,
CACHE_DURATION);
//Generate the response
this.WriteBytes(responseBytes, context, isCompressed,
contentType);
}
}
}
private byte[] GetFileBytes(HttpContext context, string virtualPath,
Encoding encoding)
{
if (virtualPath.StartsWith("http://",
StringComparison.InvariantCultureIgnoreCase))
{
using (WebClient client = new WebClient())
{
return client.DownloadData(virtualPath);
}
}
else
{
string physicalPath = context.Server.MapPath(virtualPath);
byte[] bytes = File.ReadAllBytes(physicalPath);
//TODO: Convert unicode files to specified encoding.
//For now, assuming files are either ASCII or UTF8
return bytes;
}
}
private bool WriteFromCache(HttpContext context, string setName,
string version, bool isCompressed, string contentType)
{
byte[] responseBytes = context.Cache[GetCacheKey(setName, version,
isCompressed)] as byte[];
if (null == responseBytes || 0 == responseBytes.Length) return false;
this.WriteBytes(responseBytes, context, isCompressed, contentType);
return true;
}
private void WriteBytes(byte[] bytes, HttpContext context,
bool isCompressed, string contentType)
{
HttpResponse response = context.Response;
response.AppendHeader("Content-Length", bytes.Length.ToString());
response.ContentType = contentType;
if (isCompressed)
response.AppendHeader("Content-Encoding", "gzip");
context.Response.Cache.SetCacheability(HttpCacheability.Public);
context.Response.Cache.SetExpires(DateTime.Now.Add(CACHE_DURATION));
context.Response.Cache.SetMaxAge(CACHE_DURATION);
context.Response.Cache.AppendCacheExtension(
"must-revalidate, proxy-revalidate");
response.OutputStream.Write(bytes, 0, bytes.Length);
response.Flush();
}
private bool CanGZip(HttpRequest request)
{
string acceptEncoding = request.Headers["Accept-Encoding"];
if (!string.IsNullOrEmpty(acceptEncoding) &&
(acceptEncoding.Contains("gzip")
|| acceptEncoding.Contains("deflate")))
return true;
return false;
}
private string GetCacheKey(string setName, string version,
bool isCompressed)
{
return "HttpCombiner." + setName + "." + version + "." + isCompressed;
}
public bool IsReusable
{
get { return true; }
}
}
Ce problème peut également affecter PHP, donc je voulais faire une note de celui-ci, basée sur le titre de cette question. Lors de la NOMENCLATURE apparaît au sommet d'un fichier PHP, les en-têtes n'est pas correctement envoyé et donc de l'état de session ne tient pas entre les pages. Il peut être ahurissant de les pourchasser et de les résoudre, à moins que vous avez déjà vu ça avant. Le problème est qu'un fichier PHP a été enregistré en UTF-8 au lieu de l'ASCII. C'est une bonne idée de sauvegarder tous les fichiers HTML, CSS, et PHP les fichiers au format ASCII. Dans mon cas, j'ai dû utiliser un éditeur hexadécimal avec la commande iconv pour détecter les caractères, les supprimer et enregistrer au format ASCII.
Commentaire... l'existence des personnages "gzip" et/ou "dégonfler" n'est pas une bonne manière de tester, il me semble. Les Clients ne voulant pas le contenu compressé peut spécifier "gzip;q=0,dégonfler;q=0", par exemple.
Commentaire... l'existence des personnages "gzip" et/ou "dégonfler" n'est pas une bonne manière de tester, il me semble. Les Clients ne voulant pas le contenu compressé peut spécifier "gzip;q=0,dégonfler;q=0", par exemple.
OriginalL'auteur IEnumerator | 2009-01-21
Vous devez vous connecter pour publier un commentaire.
OK, j'ai débogué votre code.
NOMENCLATURE des marques apparaissent dans le cours d'eau de source lorsque les fichiers sont lus à partir du disque:
Si vous lisez correctement les fichiers, vous pouvez vous débarrasser de la marque.
OriginalL'auteur DreamSonic
Ï»¿ les personnages sont la UTF NOMENCLATURE des marqueurs.
OriginalL'auteur Stefan
Son UTF Marque d'Ordre des octets (BOM).
Il le sera au début de chaque fichier, mais votre éditeur de les ignorer. Lorsque concaténé ils se retrouvent dans le milieu, de sorte que vous les voyez.
OriginalL'auteur Greg
Je pense que c'est le Marque d'Ordre des octets (BOM) pour les fichiers avec l'encodage UTF-8. Cette marque permet de déterminer dans quel encodage du fichier est stocké.
OriginalL'auteur M4N
Si vous avez le contenu du fichier dans une chaîne .Trim() lop off de la "compilation de NOMENCLATURE" tout à fait haut la main.
Vous ne pouvez pas être en mesure de le faire, ou vous pouvez voulez les espaces à la fin du fichier, mais il est certainement une option.
Pour .js espace n'est pas important, de sorte que cela pourrait fonctionner.
OriginalL'auteur Broam
Vérifier comment votre js fichiers sont encodés et de fournir le même encodage dans le code qui effectue la lecture et la concaténation. Ces deux personnages généralement point à unicode.
OriginalL'auteur Boris Pavlović
Ces caractères UTF-8 BOM. Il ne semble pas comme ils viennent de le format de flux. Il est plus probable qu'ils sont insérés les flux de réponse, je vous suggère de compensation de la réponse avant de travailler avec elle:
OriginalL'auteur DreamSonic
Vous ne publiez pas ce que la solution elle-même a été. Voici mon soulution. Sur la ligne où il lit le fichier en mémoire, je l'ai trouvé un peu étrange la façon de le supprimer de la NOMENCLATURE:
Et vous avez aussi besoin de cette fonction:
Nitech
OriginalL'auteur nitech