Come posso ottimizzare questo codice C #?
-
23-09-2019 - |
Domanda
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 ...
Soluzione
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 =)
Altri suggerimenti
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.
Si potrebbe riordinare alcuni bit:
- Usa
string.Format()
per evitare sequenzex + y + z
lunghi. Questo può o non può fare le cose più velocemente (sarebbe marginale in entrambi i casi). - 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.
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.
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
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();
}
Vorrei suggerire una soluzione diversa, se si utilizza .net 3.0 o 3.5
invece di fare questo
- Convertire DataTable in xml
- uso XmlSerializer per convertire il codice XML per l'oggetto dominio
- Uso JavaScriptSerializer (System.Web.Extensions.dll) per serializzare l'oggetto dominio stringa JSON.