Modifier une ressource incorporée par programmation avant de l'enregistrer/référencer sur la page

Question

Premièrement, "Modifier" peut être le mauvais terme, je vois que quelques personnes ont posté en ligne en demandant simplement s'ils peuvent réellement modifier une ressource incorporée. Ce que je veux, c'est utiliser une ressource dans mon assemblage comme une sorte de gabarit que je ferais trouver et remplacer avant de l'enregistrer sur la page - est-ce possible?

Par exemple; disons que j'ai quelques lignes de jQuery en tant que ressource intégrée dans mon assembly et dans ce script, je fais référence à un nom de classe CSS qui peut être défini par le programmeur frontal. Puisque je ne sais pas ce que sera la classe CSS avant l'implémentation, y a-t-il un moyen de parcourir la ressource intégrée et de remplacer, par exemple, $ myclass $ par ThisClassName.

Toute aide serait appréciée, si ce n'est pas possible alors au moins dites-le moi pour que je puisse arrêter de courir après ma queue.

Answer 1

J'ai résolu mon petit problème en créant un gestionnaire HTTP. Dans ce cas, il s'appelle DynamicClientScript.axd. J'ai pris quelques coupes de mon code pour vous donner une idée. Le code ci-dessous obtient l'URL de ressource intégrée standard et prend la chaîne de requête à ajouter au chemin d'accès à mon gestionnaire.

/// <summary> 
    /// Gets the dynamic web resource URL to reference on the page. 
    /// </summary> 
    /// <param name="type">The type of the resource.</param> 
    /// <param name="resourceName">Name of the resource.</param> 
    /// <returns>Path to the web resource.</returns> 
    public string GetScriptResourceUrl(Type type, string resourceName) 
    { 
     this.scriptResourceUrl = this.currentPage.ClientScript.GetWebResourceUrl(type, resourceName); 

     string resourceQueryString = this.scriptResourceUrl.Substring(this.scriptResourceUrl.IndexOf("d=")); 

     DynamicScriptSessionManager sessMngr = new DynamicScriptSessionManager(); 
     Guid paramGuid = sessMngr.StoreScriptParameters(this.Parameters); 

     return string.Format("/DynamicScriptResource.axd?{0}&paramGuid={1}", resourceQueryString, paramGuid.ToString()); 
    } 

    /// <summary> 
    /// Registers the client script include. 
    /// </summary> 
    /// <param name="key">The key of the client script include to register.</param> 
    /// <param name="type">The type of the resource.</param> 
    /// <param name="resourceName">Name of the resource.</param> 
    public void RegisterClientScriptInclude(string key, Type type, string resourceName) 
    { 
     this.currentPage.ClientScript.RegisterClientScriptInclude(key, this.GetScriptResourceUrl(type, resourceName)); 
    } 

Le gestionnaire prend alors sa chaîne de requête pour créer l'URL à la ressource standard. Lit la ressource et remplace chaque clé par sa valeur dans la collection de dictionnaire (DynamicClientScriptParameters).

Le paramGuid est un identificateur utilisé pour obtenir la bonne collection de paramètres de script.

Qu'est-ce que le gestionnaire ne ...

 public void ProcessRequest(HttpContext context) 
    { 
     string d = HttpContext.Current.Request.QueryString["d"]; 
     string t = HttpContext.Current.Request.QueryString["t"]; 
     string paramGuid = HttpContext.Current.Request.QueryString["paramGuid"]; 

     string urlFormatter = "http://" + HttpContext.Current.Request.Url.Host + "/WebResource.axd?d={0}&t={1)"; 

     // URL to resource. 
     string url = string.Format(urlFormatter, d, t); 

     string strResult = string.Empty; 

     WebResponse objResponse; 
     WebRequest objRequest = System.Net.HttpWebRequest.Create(url); 

     objResponse = objRequest.GetResponse(); 

     using (StreamReader sr = new StreamReader(objResponse.GetResponseStream())) 
     { 
      strResult = sr.ReadToEnd(); 

      // Close and clean up the StreamReader 
      sr.Close(); 
     } 

     DynamicScriptSessionManager sessionManager = (DynamicScriptSessionManager)HttpContext.Current.Application["DynamicScriptSessionManager"]; 

     DynamicClientScriptParameters parameters = null; 

     foreach (var item in sessionManager) 
     { 
      Guid guid = new Guid(paramGuid); 

      if (item.SessionID == guid) 
      { 
       parameters = item.DynamicScriptParameters; 
      } 
     } 

     foreach (var item in parameters) 
     { 
      strResult = strResult.Replace("$" + item.Key + "$", item.Value); 
     } 

     // Display results to a webpage 
     context.Response.Write(strResult); 
    } 

Puis dans mon code où je veux faire référence à ma ressource que j'utiliser ce qui suit.

  DynamicClientScript dcs = new DynamicClientScript(this.GetType(), "MyNamespace.MyScriptResource.js"); 

     dcs.Parameters.Add("myParam", "myValue"); 

     dcs.RegisterClientScriptInclude("scriptKey"); 

dit alors ma ressource de script contient:

alert('$myParam$'); 

Il sortira comme si elle était:

alert('myValue'); 

Mon code fait aussi de la mise en cache (en utilisant le DynamicScriptSessionManager) mais vous obtenez l'idée ...

Cheers

Answer 2

Dans votre codebehind, vous pouvez lire le contenu de la ressource intégrée, remplacer ce que vous voulez, puis écrire le nouveau contenu dans la réponse. Quelque chose comme ceci:

protected void Page_Load(object sender, EventArgs e) 
{ 
    string contents = ReadEmbeddedResource("ClassLibrary1", "ClassLibrary1.TestJavaScript.js"); 
    //replace part of contents 
    //write new contents to response 
    Response.Write(String.Format("<script>{0}</script>", contents)); 
} 

private string ReadEmbeddedResource(string assemblyName, string resouceName) 
{ 
    var assembly = Assembly.Load(assemblyName); 
    using (var stream = assembly.GetManifestResourceStream(resouceName)) 
    using(var reader = new StreamReader(stream)) 
    { 
     return reader.ReadToEnd(); 
    } 
}