Come posso ottimizzare questo codice C #?

Question

Ho convertito il mio Datatable a json stringa di utilizzare il metodo seguente ...

public string GetJSONString(DataTable Dt)
{
    string[] StrDc = new string[Dt.Columns.Count];
    string HeadStr = string.Empty;
    for (int i = 0; i < Dt.Columns.Count; i++)
    {
        StrDc[i] = Dt.Columns[i].Caption;
        HeadStr += "\"" + StrDc[i] + "\" : \"" + StrDc[i] + i.ToString() + "¾" + "\",";
    }
    HeadStr = HeadStr.Substring(0, HeadStr.Length - 1);
    StringBuilder Sb = new StringBuilder();

    Sb.Append("{\"" + Dt.TableName + "\" : [");
    for (int i = 0; i < Dt.Rows.Count; i++)
    {
        string TempStr = HeadStr;
        Sb.Append("{");
        for (int j = 0; j < Dt.Columns.Count; j++)
        {
            if (Dt.Rows[i][j].ToString().Contains("'") == true)
            {
                Dt.Rows[i][j] = Dt.Rows[i][j].ToString().Replace("'", "");
            }
            TempStr = TempStr.Replace(Dt.Columns[j] + j.ToString() + "¾", Dt.Rows[i][j].ToString());
        }
        Sb.Append(TempStr + "},");
    }
    Sb = new StringBuilder(Sb.ToString().Substring(0, Sb.ToString().Length - 1));
    Sb.Append("]}");
    return Sb.ToString();
}

E 'questa fiera abbastanza o ancora non v'è margine per l'ottimizzazione per rendere l'esecuzione più veloce .... Ogni suggerimento ...

Answer 1

Prima di chiedere se è possibile ottimizzare per renderlo più veloce esecuzione, la prima domanda è necessario porsi è, vuol correre abbastanza veloce per me? ottimizzazione prematura è la maledizione di tutti noi (che so l'ho fatto!). Si potrebbe passare ore a cercare di micro-ottimizzare questo codice, che potrebbe prendere da prendere, per esempio, 20ms di eseguire fino a 15ms. Sì che sarebbe una riduzione del 25%, ma sarebbe 5ms davvero la pena di 2 ore del vostro tempo? Ancora più importante, sarebbe fornire abbastanza di un beneficio per gli utenti finali per giustificarlo?

Hai pensato di usare la JsonSerializer da "Newtonsoft" ? Questo potrebbe essere "abbastanza veloce", è abbastanza ampiamente utilizzato ed è quindi più probabile che sia corretto nel complesso di qualsiasi cosa, oppure, può scrivere al primo colpo.

puramente da un punto di vista leggibilità (che può anche permettere il compilatore C # / CLR per migliorare cosa per voi) si potrebbe pensare di cambiare lunghi pezzi di concatenazione di stringhe come ad esempio:

HeadStr += "\"" + StrDc[i] + "\" : \"" + StrDc[i] + i.ToString() + "¾" + "\",";

A:

HeadStr += string.Format("\"{0}\" : \"{0}{1}¾\",", strDc[i], i);

Ma per eventuali modifiche si fanno. Misura, risciacquo, Repeat =)

Answer 2

Ci possono anche essere modi di ottenerlo per l'esecuzione più veloce - ma hai qualche indicazione che si necessità per eseguire più velocemente? Avete una buona ragione per credere che questo è un collo di bottiglia significativo nel codice? Se è così, punto di riferimento il codice con alcuni dati reali e profilare la routine di capire dove il tempo sta andando.

Answer 3

Si potrebbe riordinare alcuni bit:

1. Usa string.Format() per evitare sequenze x + y + z lunghi. Questo può o non può fare le cose più velocemente (sarebbe marginale in entrambi i casi).
2. Di solito non è necessario .toString() quando la concatenazione.

Si potrebbe anche passare in StringBuffer a popolarsi, in modo che il chiamante può avere la possibilità di impacchettare parecchi di tali operazioni in un unico StringBuffer.

Questi suggerimenti sono aspettare gli ordine di prestazioni, che a mio avviso dovrebbe essere il vero centro a meno che questo codice presenta come un collo di bottiglia nel vostro profiling.

Answer 4

Perché pensi che ha bisogno di ottimizzazione? E 'davvero lento su alcuni DataTable? Avevo appena serializzare DataTable con qualcosa di simile a newton JSON serializzatore, se è serializzabile a tutti.

Answer 5

Refactor il codice, utilizzare uno strumento come ReSharper, JustCode ecc per riordinare su una punta. metodi di estrarre e utilizzare le prove individuali (Test Driven Development-ish) per trovare i colli di bottiglia nel codice e quindi modificare quelli.

Ma il primo passo dovrebbe essere: Refactor

Answer 6

Il problema con il codice non è la velocità, ma che non è ripulito. Ho fatto un po 'di pulizia, ma probabilmente si potrebbe fare ancora di più:

public string GetJSONString2(DataTable table)
{
    StringBuilder headStrBuilder = new StringBuilder(table.Columns.Count * 5); //pre-allocate some space, default is 16 bytes
    for (int i = 0; i < table.Columns.Count; i++)
    {
        headStrBuilder.AppendFormat("\"{0}\" : \"{0}{1}¾\",", table.Columns[i].Caption, i);
    }
    headStrBuilder.Remove(headStrBuilder.Length - 1, 1); // trim away last ,

    StringBuilder sb = new StringBuilder(table.Rows.Count * 5); //pre-allocate some space
    sb.Append("{\"");
    sb.Append(table.TableName);
    sb.Append("\" : [");
    for (int i = 0; i < table.Rows.Count; i++)
    {
        string tempStr = headStrBuilder.ToString();
        sb.Append("{");
        for (int j = 0; j < table.Columns.Count; j++)
        {
            table.Rows[i][j] = table.Rows[i][j].ToString().Replace("'", "");
            tempStr = tempStr.Replace(table.Columns[j] + j.ToString() + "¾", table.Rows[i][j].ToString());
        }
        sb.Append(tempStr + "},");
    }
    sb.Remove(sb.Length - 1, 1); // trim last ,
    sb.Append("]}");
    return sb.ToString();
}

Answer 7

Vorrei suggerire una soluzione diversa, se si utilizza .net 3.0 o 3.5

invece di fare questo

1. Convertire DataTable in xml
2. uso XmlSerializer per convertire il codice XML per l'oggetto dominio
3. Uso JavaScriptSerializer (System.Web.Extensions.dll) per serializzare l'oggetto dominio stringa JSON.