c# - separar - Diferencia entre ToCharArray y ToArray

text to array c#

Question

¿Cuál es la diferencia entre ToCharArray y ToArray

string mystring = "abcdef";
char[] items1 = mystring.ToCharArray();
char[] items2 = mystring.ToArray();

El resultado parece ser el mismo.

Answer 1

Método ToCharArray:

Método ToCharArray para extraer los caracteres de una cadena a una matriz de caracteres. A continuación, muestra la cadena original y los elementos de la matriz.

using System;
public class Example
{
public static void Main()
{
String s = "AaBbCcDd";
var chars = s.ToCharArray();
Console.WriteLine("Original string: {0}", s);
Console.WriteLine("Character array:");
for (int ctr = 0; ctr < chars.Length; ctr++)
Console.WriteLine(" {0}: {1}", ctr, chars[ctr]);
}
}

Método ToArray:

Método ToArray de la clase List que actúa sobre rangos.

using System;
using System.Collections.Generic;
public class Example
{
public static void Main()
{
string[] input = { "Brachiosaurus",
"Amargasaurus",
"Mamenchisaurus" };
List<string> dinosaurs = new List<string>(input);
Console.WriteLine("/nCapacity: {0}", dinosaurs.Capacity);
Console.WriteLine();
foreach( string dinosaur in dinosaurs )
{
Console.WriteLine(dinosaur);
}
Console.WriteLine("/nAddRange(dinosaurs)");
dinosaurs.AddRange(dinosaurs);
Console.WriteLine();
foreach( string dinosaur in dinosaurs )
{
Console.WriteLine(dinosaur);
}
Console.WriteLine("/nRemoveRange(2, 2)");
dinosaurs.RemoveRange(2, 2);
Console.WriteLine();
foreach( string dinosaur in dinosaurs )
{
Console.WriteLine(dinosaur);
}
input = new string[] { "Tyrannosaurus",
"Deinonychus",
"Velociraptor"};
Console.WriteLine("/nInsertRange(3, input)");
dinosaurs.InsertRange(3, input);
Console.WriteLine();
foreach( string dinosaur in dinosaurs )
{
Console.WriteLine(dinosaur);
}
Console.WriteLine("/noutput = dinosaurs.GetRange(2, 3).ToArray()");
string[] output = dinosaurs.GetRange(2, 3).ToArray();
Console.WriteLine();
foreach( string dinosaur in output )
{
Console.WriteLine(dinosaur);
}
}
}

Answer 2

Si estamos hablando de convertir cadenas en letras, la función ToCharArray () es más rápida que ToArray ()

Answer 3

string.ToCharArray() es un miembro de la clase de cadena.

string.ToArray() está usando una extensión ToArray() de IEnumerable<T> , aprovechando el hecho de que string implementa IEnumerable<char> .

De los dos, es probable que string.ToCharArray() sea ​​más string.ToCharArray() .

Desde la fuente de referencia de C #, la implementación de string.ToCharArray() es:

unsafe public char[] ToCharArray() {
// <
int length = Length;
char[] chars = new char[length];
if (length > 0)
{
fixed (char* src = &this.m_firstChar)
fixed (char* dest = chars) {
wstrcpy(dest, src, length);
}
}
return chars;
}

También desde la fuente de referencia de C #, la implementación de IEnumerable<T>.ToArray() es:

public static TSource[] ToArray<TSource>(this IEnumerable<TSource> source) {
if (source == null) throw Error.ArgumentNull("source");
return new Buffer<TSource>(source).ToArray();
}
...
struct Buffer<TElement>
{
internal TElement[] items;
internal int count;
internal Buffer(IEnumerable<TElement> source) {
TElement[] items = null;
int count = 0;
ICollection<TElement> collection = source as ICollection<TElement>;
if (collection != null) {
count = collection.Count;
if (count > 0) {
items = new TElement[count];
collection.CopyTo(items, 0);
}
}
else {
foreach (TElement item in source) {
if (items == null) {
items = new TElement[4];
}
else if (items.Length == count) {
TElement[] newItems = new TElement[checked(count * 2)];
Array.Copy(items, 0, newItems, 0, count);
items = newItems;
}
items[count] = item;
count++;
}
}
this.items = items;
this.count = count;
}
internal TElement[] ToArray() {
if (count == 0) return new TElement[0];
if (items.Length == count) return items;
TElement[] result = new TElement[count];
Array.Copy(items, 0, result, 0, count);
return result;
}
} 

Como puedes ver, eso es mucho más complicado!

¿Por qué IEnumerable<T>.ToArray() usa la ruta optimizada?

Hay otra cosa que necesitamos explicar.

Si inspecciona la implementación de Buffer<T> verá esta optimización:

ICollection<TElement> collection = source as ICollection<TElement>;
if (collection != null) {
count = collection.Count;
if (count > 0) {
items = new TElement[count];
collection.CopyTo(items, 0);
}
} 

¿Podría razonablemente preguntar por qué no se toma ese camino? Si lo fuera, esta sería una buena optimización para string.ToArray() .

Bueno, la respuesta es simple: una string no implementa ICollection<T> y, por lo tanto, la source as ICollection<TElement> devolverá el valor nulo, y esa optimización no se realizará.

Peor aún, la ruta no optimizada a través de Buffer<T> usará el enumerador de string , que se implementa de la siguiente manera:

public sealed class CharEnumerator : IEnumerator, ICloneable, IEnumerator<char>, IDisposable
{
private String str;
private int index;
private char currentElement;
internal CharEnumerator(String str) {
Contract.Requires(str != null);
this.str = str;
this.index = -1;
}
public Object Clone() {
return MemberwiseClone();
}
public bool MoveNext() {
if (index < (str.Length-1)) {
index++;
currentElement = str[index];
return true;
}
else
index = str.Length;
return false;
}
public void Dispose() {
if (str != null)
index = str.Length;
str = null;
}
/// <internalonly/>
Object IEnumerator.Current {
get {
if (index == -1)
throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumNotStarted));
if (index >= str.Length)
throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumEnded));
return currentElement;
}
}
public char Current {
get {
if (index == -1)
throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumNotStarted));
if (index >= str.Length)
throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumEnded));
return currentElement;
}
}
public void Reset() {
currentElement = (char)0;
index = -1;
}
}
ICollection<TElement> collection = source as ICollection<TElement>;
if (collection != null) {
count = collection.Count;
if (count > 0) {
items = new TElement[count];
collection.CopyTo(items, 0);
}
} 

Esto introduce otro nivel de ineficiencia.

La moraleja de esta historia

Nunca use IEnumerable<char>.ToArray() lugar de string.ToCharArray() !