chaîne de caractères.substring vs chaîne.prendre

Comme Henk Holtermand dit, Take() crée un IEnumerator et puis vous avez besoin de la ToArray() appel.

Donc, si l' performance est important dans votre application, ou vous allez effectuer des sous-chaînes à plusieurs reprises dans vos processus, le rendement pourrait être un problème.

J'ai écrit un exemple de programme de référence exactement comment plus lent est le Take() méthode voici les résultats:

Testé avec dix millions de fois:

• De temps à effectuer des sous-chaîne: 266 ms
• Temps de prendre de l'opération: 1437 ms

Et voici le code:

    internal const int RETRIES = 10000000;

    static void Main(string[] args)
    {
        string testString = Guid.NewGuid().ToString();

        long timeSubstring = MeasureSubstring(testString);
        long timeTake = MeasureTake(testString);

        Console.WriteLine("Time substring: {0} ms, Time take: {1} ms",
            timeSubstring, timeTake);
    }

    private static long MeasureSubstring(string test)
    {
        long ini = Environment.TickCount;

        for (int i = 0; i < RETRIES; i++)
        {
            if (test.Length > 4)
            {
                string tmp = test.Substring(4);
            }
        }

        return Environment.TickCount - ini;
    }

    private static long MeasureTake(string test)
    {
        long ini = Environment.TickCount;

        for (int i = 0; i < RETRIES; i++)
        {
            var data = new string(test.Take(4).ToArray());
        }

        return Environment.TickCount - ini;
    }

Une variation de @Daniel réponse qui me paraît plus juste.

un Guid de la longueur est de 36. Nous sommes en train de créer une liste avec une longueur variable de chaînes de 1 à 36, et nous allons viser pour la prise de 18 ans avec l' substring /take méthodes, de sorte que près de la moitié ira de travers.

Les résultats que j'obtiens suggèrent que Take sera 6 à 10 fois plus lent que Substring.

Exemple de résultats :

Build time: 3812 ms
Time substring: 391 ms, Time take: 1828 ms

Build time: 4172 ms
Time substring: 406 ms, Time take: 2141 ms

donc, pour 5 millions de chaînes, en faisant à peu près 2,5 millions d'opérations, le temps total est 2,1 secondes , ou autour de 0.0008564 millisecondes = ~ 1 micro seconde par opération. Si vous sentez que vous avez besoin de la couper en 5 pour la sous-chaîne, allez-y, mais je doute que dans la vie réelle, en dehors de collants de la boucle, vous allez jamais sentir la différence.

void Main()
{
Console.WriteLine("Build time: {0} ms", BuildInput());
Console.WriteLine("Time substring: {0} ms, Time take: {1} ms", MeasureSubstring(), MeasureTake());
}
internal const int RETRIES = 5000000;
static internal List<string> input;
//Measure substring time
private static long MeasureSubstring()
{
var v = new List<string>();
long ini = Environment.TickCount;
foreach (string test in input)
if (test.Length > 18)
{
v.Add(test.Substring(18));
}
//v.Count().Dump("entries with substring");
//v.Take(5).Dump("entries with Sub");
return Environment.TickCount - ini;
}
//Measure take time
private static long MeasureTake()
{
var v = new List<string>();
long ini = Environment.TickCount;
foreach (string test in input)
if (test.Length > 18) v.Add(new string(test.Take(18).ToArray()));
//v.Count().Dump("entries with Take");
//v.Take(5).Dump("entries with Take");
return Environment.TickCount - ini;
}
//Create a list with random strings with random lengths
private static long BuildInput()
{
long ini = Environment.TickCount;
Random r = new Random();
input = new List<string>();
for (int i = 0; i < RETRIES; i++)
input.Add(Guid.NewGuid().ToString().Substring(1,r.Next(0,36)));
return Environment.TickCount - ini;
}

La Take méthode d'extension ne crée pas de sous-chaîne, elle renvoie une requête qui peut être utilisé pour créer un Char[](ToArray) ou un List<Char>(ToList). Mais vous voulez vraiment avoir cette sous-chaîne.

Alors vous avez besoin d'autres méthodes:

string  data = new string(temp.Take(20).ToArray());

Cette implicitement utilise un foreach pour énumérer les caractères, crée un nouveau char[] (ce qui pourrait allouer trop de taille en raison du doublement de l'algorithme). Enfin une nouvelle chaîne est créé à partir de la char[].

La Substring d'autre part utilise méthodes optimisées.

De sorte que vous payez ce petit commodité avec la mémoire qui pourrait être négligeable, mais pas toujours.