¿Hay alguna manera simple de concatenar dos BitArray (C# .NET)?

Question

que tienen

var previous = new BitArray(new bool[]{true}); 
var current = new BitArray(new bool[]{false}); 

que desea concatenar ellos. Ya lo he intentado:

var next = new BitArray(previous.Count + current.Count); 
var index = 0; 
for(;index < previous.Count; index++) 
    next[index] = previous[index]; 
var j = 0; 
for(;index < next.Count; index++, j++) 
    next[index] = current[j]; 
previous = current; 

Pero no parece la mejor manera de hacerlo.

Answer 1

Desafortunadamente, parece que su método podría ser tan bueno como sea posible: si BitArray implementó IEnumerable <T> (en lugar de solo IEnumerable) entonces podríamos usar los métodos de extensión LINQ para hacerlo un poco más bonito.

Si yo fuera usted, me gustaría terminar con esto en un método de extensión en BitArray:

public static BitArray Prepend(this BitArray current, BitArray before) { 
    var bools = new bool[current.Count + before.Count]; 
    before.CopyTo(bools, 0); 
    current.CopyTo(bools, before.Count); 
    return new BitArray(bools); 
} 

public static BitArray Append(this BitArray current, BitArray after) { 
    var bools = new bool[current.Count + after.Count]; 
    current.CopyTo(bools, 0); 
    after.CopyTo(bools, current.Count); 
    return new BitArray(bools); 
} 

Answer 2

El marco no proporciona una buena manera de hacer esto. Podría crear una matriz de bools que sea lo suficientemente grande como para almacenar ambas BitArrays. Luego use BitArray.CopyTo para copiar cada BitArray en la matriz de bools (puede especificar dónde comenzar a insertar los elementos).

Una vez hecho esto, cree otro BitArray con el constructor que acepte una matriz de bools.

Mucho trabajo que conozco, pero parece que no hay otra manera. Sin embargo, es menos código que tu método actual.

Answer 3

Uno puede hacer esto con LINQ, después de Cast<bool>() la BitArray 'se convierte en' IEnumerable<bool>:

var previous = new BitArray(new bool[] { true }); 
var current = new BitArray(new bool[] { false }); 

BitArray newBitArray = 
    new BitArray(previous.Cast<bool>().Concat(current.Cast<bool>()).ToArray()); 

no creo que este método de LINQ será rápido.

Answer 4

Es más eficiente si usa int32 en lugar de bools porque bitarray usa int32 internamente.

public static BitArray Append(this BitArray current, BitArray after) { 
    var ints = new int[(current.Count + after.Count)/32]; 
    current.CopyTo(ints, 0); 
    after.CopyTo(ints, current.Count/32); 
    return new BitArray(ints); 
} 

En Vb.net si alguien lo necesita:

<Runtime.CompilerServices.Extension()> _ 
Public Function Append(ByVal current As BitArray, ByVal after As BitArray) As BitArray 
    Dim ints = New Int32((current.Count + after.Count) \ 32 - 1) {} 
    current.CopyTo(ints, 0) 
    after.CopyTo(ints, current.Count \ 32) 
    Return New BitArray(ints) 
End Function 

Answer 5

Aquí está mi aplicación de LINQ que no incluye la sobrecarga de tener que asignar una matriz de Bools:

var result = new BitArray(first.Count + second.Count); 

var i = 0; 
foreach (var value in first.Cast<bool>().Concat(second.Cast<bool>())) 
{ 
    result[i++] = value; 
}