Sprawdzanie równości dla dwóch tablic bajtowych

Sprawdzam równość dwóch tablic bajtowych i chciałem pomocy, ponieważ to co zwróciło fałsz, mimo że tablice powinny być równe.Sprawdzanie równości dla dwóch tablic bajtowych

Wewnątrz mojego debugowania widziałem zarówno a1 jak i b1 są równe, ale to nie wchodzi w pętlę while do inkrementacji i.

public bool Equality(byte[] a1, byte[] b1) 
{ 
    int i; 
    bool bEqual; 
    if (a1.Length == b1.Length) 
    { 
     i = 0; 
     while ((i < a1.Length) && (a1[i]==b1[i])) 
     { 
      i++; 
     } 

     if (i == a1.Length) 
     { 
      bEqual = true; 
     } 
    } 
    return bEqual; 
}

To zawsze zwraca wartość false: (a1[i]==b1[i]).

Źródło

2013-08-27 Masriyah

Gdzie jest zwrot? – Moop

Czy hashB ma być b1? –

o ile mogę powiedzieć, że nic nie zwraca. –

Musisz gdzieś dodać wartość zwracaną. To powinno działać:

public bool Equality(byte[] a1, byte[] b1) 
{ 
    int i; 
    if (a1.Length == b1.Length) 
    { 
     i = 0; 
     while (i < a1.Length && (a1[i]==b1[i])) //Earlier it was a1[i]!=b1[i] 
     { 
      i++; 
     } 
     if (i == a1.Length) 
     { 
      return true; 
     } 
    } 

    return false; 
}

Ale to jest znacznie prostsze:

return a1.SequenceEqual(b1);

Alternatywnie, można użyć IStructuralEquatable z .NET 4:

return ((IStructuralEquatable)a1).Equals(b1, StructuralComparisons.StructuralEqualityComparer)

Źródło

2013-08-27 18:33:37

używam tego do porównywania dwóch różnych plików i zwracam różnicę (jakie rekordy zostały dodane lub usunięte), a nie, że działa i pętle poprawnie nie otrzymuję zwróconej wiadomości o różnicy plików, w których jeden plik miał usunięte rekordy – Masriyah

@Masriyah Więc co naprawdę chcesz zrobić, to zaimplementować algorytm diff? To zupełnie inne zadanie niż po prostu sprawdzanie równości. Polecam zapoznanie się z biblioteką Google [diff-match-patch] (https://code.google.com/p/google-diff-match-patch/). –

Poszedłem dalej i przesłałem pozostałe części mojego kodu, które się z tym wiążą. Może możesz rzucić okiem i coś wskazać. biegłam w kółko przez cały dzień. dzięki – Masriyah

To powinno działać:

public bool Equality(byte[] a1, byte[] b1) 
{ 
    if(a1 == null || b1 == null) 
     return false; 
    int length = a1.Length; 
    if(b1.Length != length) 
     return false; 
    while(length >0) { 
     length--; 
     if(a1[length] != b1[length]) 
      return false;   
    } 
    return true;   
}

Źródło

2013-08-27 18:31:04 Moop

Należy dodać niektóre wypowiedzi Powrót:

public bool Equality(byte[] a1, byte[] b1) 
{ 
    int i = 0; 
    if (a1.Length == b1.Length) 
    { 
     while ((i < a1.Length) && (a1[i]==b1[i])) 
     { 
      i++; 
     } 
    } 
    return i == a1.Length; 
}

Albo, jeszcze lepiej

public bool Equality(byte[] a1, byte[] b1) 
{ 
    if(a1.Length != b1.Length) 
    { 
     return false; 
    } 

    for (int i = 0; i < a1.Length; i++) 
    { 
     if (a1[i] != b1[i]) 
     { 
      return false; 
     } 
    } 
    return true; 
}

Źródło

2013-08-27 18:31:16

Twoja druga odpowiedź może rzucić wyjątek IndexOutOfBounds – Moop

Najpierw sprawdź długość, jest tańsza. –

Pierwsza nie będzie działać, ponieważ jeśli "a1.Length == 0" i "b1.Length> 0' –

Aby sprawdzić równość można po prostu napisać:

var areEqual = a1.SequenceEqual(b1);

Źródło

2013-08-27 18:32:20 Magnus

To technicznie wymaga LINQ, który może nie pasować do jego struktury – Moop

Ale jeśli nie pasuje do jego ramy to jest o wiele lepszy sposób robienia tego. –

@Moop Linq istnieje już od 6 lat, z pewnością większość osób zaktualizowała się do co najmniej wersji 3.5. – Magnus

Chciałbym polecić jakieś zwarcia aby nieco uprościć i użyć object.ReferenceEquals do zwarcia dla przypadków, gdy tablice mają takie same referencje (a1 = b1):

public bool Equality(byte[] a1, byte[] b1) 
{ 
    // If not same length, done 
    if (a1.Length != b1.Length) 
    { 
     return false; 
    } 

    // If they are the same object, done 
    if (object.ReferenceEquals(a1,b1)) 
    { 
     return true; 
    } 

    // Loop all values and compare 
    for (int i = 0; i < a1.Length; i++) 
    { 
     if (a1[i] != b1[i]) 
     { 
      return false; 
     } 
    } 

    // If we got here, equal 
    return true; 
}

Źródło

2013-08-27 19:01:13 Haney

Sprawdzanie równości dla dwóch tablic bajtowych

Odpowiedz

Powiązane problemy