Question

Je l'ai converti mon Datatable à json chaîne utilisez la méthode suivante ...

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

Est-ce assez juste ou encore il y a marge d'optimisation pour faire exécuter plus vite .... Toute suggestion ...

Était-ce utile?

La solution

Avant de demander si vous pouvez l'optimiser pour faire exécuter plus rapidement, la première question que vous devez vous demander est, il ne fonctionne pas assez vite pour moi? L'optimisation prématurée est la malédiction de nous tous (je sais que je l'ai fait!). Vous pourriez passer des heures à essayer de micro-optimize ce code, ce qui pourrait prendre de prendre, par exemple, 20ms pour exécuter jusqu'à 15ms. Oui ce serait une réduction de 25%, mais serait 5ms vraiment la peine 2 heures de votre temps? Plus important encore, serait-il fournir assez d'un avantage pour vos utilisateurs finaux pour le justifier?

Avez-vous envisagé d'utiliser le JsonSerializer de "Newtonsoft"? Cela pourrait bien être « assez rapide », est assez largement utilisé et est donc plus susceptible d'être correcte dans l'ensemble que tout ce que je, ou vous, peut écrire la première fois-ci.

Purement du point de vue de la lisibilité (qui peut également permettre au compilateur C # / CLR pour améliorer chose pour vous), vous pouvez envisager de changer de longs morceaux de concaténation de chaîne tels que:

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

Pour:

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

Mais pour les changements que vous ne faites. Mesure, rinçage, répétition =)

Autres conseils

Il peut y avoir des moyens de l'obtenir pour exécuter plus rapidement - mais avez-vous une indication que vous besoin à exécuter plus vite? Avez-vous une bonne raison de croire que c'est un goulot d'étranglement important dans votre code? Dans ce cas, le code de référence avec des données réelles et le profil de la routine pour déterminer où le temps va.

Vous pouvez ranger quelques bits:

  1. Utilisez string.Format() pour éviter de longues séquences de x + y + z. Cela peut ou ne peut pas rendre les choses plus rapidement (il serait de toute façon marginale).
  2. Vous n'avez pas besoin généralement .toString() quand concaténer.

Vous pouvez également passer dans le StringBuffer être peuplé, de sorte que l'appelant pourrait avoir la possibilité de regrouper plusieurs des ces opérations en un seul StringBuffer.

Ces suggestions sont axées davantage sur la performance que la bonne tenue, que je pense devrait être le véritable objectif à moins que ce code présente comme un goulot d'étranglement dans votre profil.

Pourquoi pensez-vous qu'il a besoin d'optimisation? Est-il vraiment lent sur certains DataTables? Je venais de sérialiser DataTable avec quelque chose comme newton JSON sérialiseur, si elle est sérialisable du tout.

Refactor votre code, utilisez un outil comme ReSharper, JustCode etc pour ranger jusqu'à un peu. méthodes d'extraction et utiliser des tests individuels (Test Driven Development-ish) pour trouver les goulots d'étranglement dans votre code, puis modifier ceux-ci.

Mais votre première étape devrait être: Refactor

Le problème avec le code est pas la vitesse, mais ce n'est pas nettoyé. Je l'ai fait un peu de nettoyage, mais vous pourriez probablement faire encore plus:

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

Je suggère une autre solution, si vous utilisez .net 3.0 ou 3.5

au lieu de le faire

  1. Convertir datatable en XML
  2. utiliser XmlSerializer pour convertir le xml à votre objet de domaine
  3. Utilisation JavaScriptSerializer (System.Web.Extensions.dll) pour sérialiser l'objet de domaine à chaîne JSON.
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top