Esiste un modo semplice per concatenare due BitArray (C# .NET)?

Question

devo

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

voglio per concatenare loro. Ho già provato:

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; 

Ma non sembra il modo migliore per farlo.

Answer 1

Sfortunatamente sembra che il tuo metodo possa essere buono come si ottiene - se BitArray ha implementato IEnumerable <T> (invece di solo IEnumerable) allora potremmo usare i metodi di estensione LINQ per renderlo un po 'più carino.

Se fossi in te, mi piacerebbe avvolgere questo in un metodo di estensione sul 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

Il quadro non fornisce un bel modo di fare questo. È possibile creare una serie di bool di dimensioni sufficienti per archiviare entrambi i BitArray. Quindi utilizzare BitArray.CopyTo per copiare ciascun BitArray nella serie di bool (è possibile specificare dove iniziare a inserire gli elementi).

Al termine, creare un altro BitArray con il costruttore che accetta una matrice di bool.

Un sacco di lavoro che conosco, ma non sembra essere un altro modo. Tuttavia è meno codice rispetto al tuo attuale metodo.

Answer 3

Si può fare questo con LINQ, dopo Cast<bool>() il BitArray 'diventa' 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()); 

non credo che questo metodo LINQ sarà veloce.

Answer 4

È più efficiente se si utilizza int32 anziché bool perché bitarray utilizza internamente int32.

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

In Vb.net se qualcuno bisogno:

<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

Ecco mia implementazione LINQ che non comprende il sovraccarico di dover allocare un array di Caccio:

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