Modifica a livello di programmazione una risorsa incorporata prima registrazione, fare riferimento alla pagina

Question

In primo luogo, "Modifica" potrebbe essere il termine sbagliato, vedo un paio di persone hanno postato online solo chiedendo se si può effettivamente modificare una risorsa incorporata.Quello che sto volendo, è l'utilizzo di una risorsa nel mio assemblea come una sorta di modello che vorrei fare un trova e sostituisci nella prima registrazione sul pagina è possibile?

Per esempio;dire che ho un paio di righe di jQuery come risorsa incorporata nel mio assemblea e in questo script ho fatto riferimento a un nome di classe CSS che possono essere impostate tramite il front-end del programmatore.Dato che non so che cosa la classe CSS sarà fino all'attuazione, c'è un modo di andare per la risorsa incorporata e sostituzione di, diciamo, $classe$ con ThisClassName.

Qualsiasi aiuto sarebbe apprezzato, se non è possibile allora dimmi almeno così posso smettere di inseguire la mia coda.

Answer 1

Ho risolto il mio piccolo problema con la creazione di un Gestore HTTP.In questo caso si chiama DynamicClientScript.axd.

Ho preso un paio di tagli dal mio codice per darvi un'idea.Il codice riportato di seguito si ottiene standard incorporato URL della risorsa e prende la stringa di query per aggiungere il percorso del mio gestore.

    /// <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));
    }

Il gestore poi prende la sua stringa di query per creare l'URL della risorsa standard.Legge le risorse e sostituisce ogni chiave con il suo valore all'interno della raccolta di dizionari (DynamicClientScriptParameters).

Il paramGuid è un identificatore utilizzato per ottenere lo script corretto insieme di parametri.

Quello che il gestore non...

        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);
    }

Quindi nel mio codice dove voglio riferimento risorse personali io uso il seguente.

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

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

        dcs.RegisterClientScriptInclude("scriptKey");

Quindi dire che il mio script di risorsa contiene:

alert('$myParam$');

Il risultato sarà come se fosse:

alert('myValue');

Il mio codice, inoltre, fa un po ' di cache (utilizzando il DynamicScriptSessionManager) ma si ottiene l'idea...

Cheers

Answer 2

In voi codebehind si potrebbe leggere il contenuto della risorsa incorporato, interruttore di quello che si vuole, e quindi la scrittura di nuovi contenuti per la risposta.Qualcosa di simile a questo:

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();
    }
}