C #: Kann nicht von ulong zu Byte konvertieren

Question

Seltsam, wie ich es in C ++ tun, aber nicht in C #.

Um es klar zu machen, ich werde die beiden Funktionen in C ++ einfügen und dann in C # und markieren Sie die problematischen Zeilen in dem C # -Code mit einem Kommentar „// error“. Was die beiden Funktion tut, ist der Parameter kodiert und dann fügen Sie in einer globalen Variablen namens byte1seeds.

Dies sind die Funktionen in C ++

//Global var:

unsigned char byte1seeds[3];

unsigned long GenerateValue( unsigned long * Ptr )
{
unsigned long val = *Ptr;
for( int i = 0; i < 32; i++ )
    val = (((((((((((val >> 2)^val) >> 2)^val) >> 1)^val) >> 1)^val) >> 1)^val)&1)|((((val&1) << 31)|(val >> 1))&0xFFFFFFFE);
return ( *Ptr = val );
}

void SetupCountByte( unsigned long seed )
{
if( seed == 0 ) seed = 0x9ABFB3B6;
unsigned long mut = seed;
unsigned long mut1 = GenerateValue( &mut );
unsigned long mut2 = GenerateValue( &mut );
unsigned long mut3 = GenerateValue( &mut );
GenerateValue( &mut );
unsigned char byte1 = (mut&0xFF)^(mut3&0xFF);
unsigned char byte2 = (mut1&0xFF)^(mut2&0xFF);
if( !byte1 ) byte1 = 1;
if( !byte2 ) byte2 = 1;
byte1seeds[0] = byte1^byte2;
byte1seeds[1] = byte2;
byte1seeds[2] = byte1;
}

Nun ist der C # -Code:

ich die Funktion GenerateValue.Instead der mit einem Zeiger als Parameter geändert haben, hat es einen ulong Parameter.

es nennen und beiden Werte ändern i verwenden:

1. ulong Mut1 = GenerateValue (mut);
2. mut = Mut1;

Hier sind die übersetzten Funktionen (die problematischen Zeilen mit „// Fehler“ gekennzeichnet);

//Global var:
public static byte[] byte1seeds = new byte[3];

public static ulong GenerateValue(ulong val)
{
    for( int i = 0; i < 32; i++ )
        val = (((((((((((val >> 2)^val) >> 2)^val) >> 1)^val) >> 1)^val) >> 1)^val)&1)|((((val&1) << 31)|(val >> 1))&0xFFFFFFFE);
    return val ;
}

public static void SetupCountByte( uint seed )
{
    if( seed == 0 ) seed = 0x9ABFB3B6;
    ulong mut = seed;
    ulong mut1 = GenerateValue(mut);
    mut = mut1;
    ulong mut2 = GenerateValue(mut);
    mut = mut2;
    ulong mut3 = GenerateValue(mut);
    mut = mut3;
    mut = GenerateValue(mut);
    byte byte1 = (mut & 0xFF) ^ (mut3 & 0xFF); //error
    byte byte2 = (mut1 & 0xFF) ^ (mut2 & 0xFF); //error
    if( byte1 != 0 )
        byte1 = 1;
    if( byte2 != 0 )
        byte2 = 1;
    byte1seeds[0] = byte1^byte2; //error
    byte1seeds[1] = byte2;
    byte1seeds[2] = byte1;
}

Der Fehler ist:

Kann nicht implizit Typ ‚ulong‘ auf ‚byte‘ konvertieren. Eine explizite Konvertierung vorhanden ist (möglicherweise fehlt eine Guss?)

edit: der Fehler bei problematischer Zeile 3:

Kann nicht implizit Typ ‚int‘ auf ‚byte‘ konvertieren. Eine explizite Konvertierung vorhanden ist (möglicherweise fehlt eine Guss?)

Hier kommt die Frage: Wie diese Fehler lösen

?

Vielen Dank im Voraus!

Answer 1

Fügen Sie einen (byte) es zu werfen. Wie Sie Präzision verlieren, müssen Sie den Compiler sagen, dass der Wert in ein Byte passen, d.

byte byte1 = (byte)((mut & 0xFF) ^ (mut3 & 0xFF));
byte byte2 = (byte)((mut1 & 0xFF) ^ (mut2 & 0xFF));

Answer 2

Sie können Informationen verloren. Der Compiler nicht über diese Art von Operationen erlauben, wenn Sie ihm explizit sagen, dies zu tun. So versuchen, so etwas wie folgt aus:

byte result = ((byte)mut & 0xFF) ^ ((byte)mut3 & 0xFF);

Auf diese Weise werden alle Variablen explizit gegossen und das Ergebnis wird ein Byte sein. Oder Sie können dies tun:

byte result = (byte)((mut & 0xFF) ^ (mut3 & 0xFF));

Answer 3

Symptom

Der folgende Code kompiliert in C ++, sondern von einem C # Compiler, mit der dritten Zeile Berichtstyp Unvereinbarkeit abgelehnt.

ulong mut = 5;
ulong mut3 = 6;
byte foo = (mut & 0xFF) ^ (mut3 & 0xFF);

Erklärung

Der Ausdruck (mut & 0xFF) ^ (mut3 & 0xFF) ist vom Typ ulong und kann nicht auf eine Variable vom Typ byte zugeordnet werden.

Die Variable mut ist ein ulong. Alle Überlastungen von & erfordern Operandentyp Symmetrie, so in dem Ausdruck (mut & 0xFF), wird der Wert auf 0xFF ulong gefördert, und das Ergebnis der Operation ist vom Typ ulong.

Während ein ähnlicher Prozess auch der zweiten subexpression den Typ ulong nicht geben, dies nebensächlich ist, weil in der größeren Ausdruck A ^ B, die Tatsache, dass die Expression A der Typ ulong würde bewirken, dass die Expression B gefördert werden muß.

Damit ist der Ausdruck (mut & 0xFF) ^ (mut3 & 0xFF) vom Typ ulong und erfordert eine explizite Umwandlung, bevor es auf eine Variable vom Typ byte zugeordnet werden kann.

Lösung

Explizit typisierte den gesamten Ausdruck vor der Zuordnung.

Bemerkungen

Menschen deaktivieren Warnungen anstatt über sie zu denken, weil die meisten C + Bibliotheken mit Fehlern gespickt sind. Wenn Sie Warnungen wieder einschalten Sie so viele bekommen es ist nutzlos versuchen, sie zu durchwaten, auch wenn irgendwo in der Messe gibt es eine Note auf die Wirkung sein, „eine potenziell verlustbehafteten implizite Typumwandlung erforderlich war“.

Wenn Sie die Sprache C # Spezifikation, insbesondere in Bezug auf Betreiber lesen, werden Sie sehr viele nützliche Dinge. Zum Beispiel wird dieser Code fehlschlagen:

byte b = 0xF0 | 0x0E; //b should contain 0xFE

aber diese erfolgreich sein wird:

byte b1 = (byte)(0xF0 | 0x0E); //typecast fixes it
byte b2 = 0xF0;
b2 |= 0x0E; //reflexive operator typed by target variable

Answer 4

„explizite Konvertierung vorhanden“ zeigt an, dass Sie eine explizite Umwandlung tun müssen. In diesem Fall, dass so etwas wäre:

byte byte1 = (byte) ( (mut & 0xFF) ^ (mut3 & 0xFF) );
byte byte2 = (byte) ( (mut1 & 0xFF) ^ (mut2 & 0xFF) );

Answer 5

Es gibt eine MSDN Knowledge Base-Artikel , die die Notwendigkeit für die expliziten gesenkten in der Tiefe erklärt. Die Worte „explizite Konvertierung vorhanden“ in der Fehlermeldung den Hinweis sein sollen, die Sie explizit den Datentyp unter Verwendung eines Guss konvertieren. In Ihrem speziellen Fall, dass würde wie folgt aussehen:

byte byte1 = (byte) ( (mut & 0xFF) ^ (mut3 & 0xFF) );