C# get-und set-das high-word der ein integer

Was ist eine effiziente oder syntaktisch einfache Möglichkeit zum abrufen und festlegen der hohe Auftragsbestand Teil ein integer?

Die Größe von einem normalen integer ist in der Regel das Wort Größe einer Maschine. Meinst du die high-order-bytes oder vielleicht die high-order word von lange?

InformationsquelleAutor James Cadd | 2009-09-17

16

Ist es das gleiche wie in C/C++:
```
//get the high order 16 bits
int high = 0x12345678 >> 16; //high = 0x1234
//set the high order 16 bits
high = (high & 0x0000FFFF) + (0x5678 << 16); //high = 0x56781234
```
EDIT:, Denn ich bin in guter Stimmung, hier gehen Sie. Denken Sie nur daran, unveränderliche Arten sind unveränderlich! Die " set " - Funktionen zugewiesen sein müssen, etwas.
```
public static class ExtensionMethods
{
    public int LowWord(this int number)
    { return number & 0x0000FFFF; }
    public int LowWord(this int number, int newValue)
    { return (number & 0xFFFF0000) + (newValue & 0x0000FFFF); }
    public int HighWord(this int number)
    { return number & 0xFFFF0000; }
    public int HighWord(this int number, int newValue)
    { return (number & 0x0000FFFF) + (newValue << 16); }
}
```
EDIT 2: Auf den zweiten Gedanken, wenn Sie wirklich brauchen, dies zu tun, und nicht wollen, dass die syntax überall verwenden Michaels Lösung. +1 zu ihm für zeigt mir etwas neues.

Danke, Weg, schnell!
Wenn Sie diese eine Menge, und wenn Sie nostalgische C-Tagen können Sie erstellen statische Methoden für diese, genannt LoWord(), HiWord(), LoByte() und HiByte(). Ich bin überrascht, dass diese ol' Makros äquivalent wurden nicht gemacht, irgendwie Teil von etwas .NET-Klasse wie Int.
Dies nutzt die Rechenleistung, das ist eine Verschwendung. Zur compile-Zeit die gewünschte bit-Muster ist schon irgendwo auf den stack und wir können sagen dem compiler, wo genau diese bit-Muster ist, so dass es kopiert werden kann, ohne irgendwelche Berechnungen. Verwenden Sie System.BitConverter.

InformationsquelleAutor Matthew Scharley

set:

MessageBox.Show( string.Format("{0:X}", 8 | 0x12340000) );

bekommen:

MessageBox.Show( string.Format("{0:X}", 0xDEADBEEF >> 16) );

[BEARBEITEN]

C# bietet eine hervorragende Unterstützung für Variablen teilen die gleiche Speicheradresse, bits und Strukturierung

Quelle: http://msdn.microsoft.com/en-us/library/acxa5b99(VS.80).aspx

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;


using System.Runtime.InteropServices;

namespace Bitwise
{
    public partial class Form1 : Form
    {

        [StructLayout(LayoutKind.Explicit)]
        struct TestUnion
        {

            [FieldOffset(0)]
            public uint Number;

            [FieldOffset(0)]
            public ushort Low;

            [FieldOffset(2)]
            public ushort High;
        }

        public Form1()
        {
            InitializeComponent();    

            var x = new TestUnion { Number = 0xDEADBEEF };        
            MessageBox.Show(string.Format("{0:X} {1:X} {2:X}", x.Number, x.High, x.Low));

            x.High = 0x1234;                
            MessageBox.Show(string.Format("{0:X} {1:X} {2:X}", x.Number, x.High, x.Low));

            x.Low = 0x5678;
            MessageBox.Show(string.Format("{0:X} {1:X} {2:X}", x.Number, x.High, 

        }
    }
}

HINWEIS: da C# nicht makro Funktion, die obige Vorgehensweise ist performant, als durch die variable Methoden/Erweiterung Methoden

+1 für zeigt mir etwas neues. Jetzt habe ich etwas neues zu missbrauchen.
Dieses ist extrem nützlich und clever! Es ist viel mehr einfach zu bedienen und funktioniert problemlos, sowohl für die Anreise und für die Einstellung der low-und high-order-Werte. Vielen Dank für das teilen dieses wissen!

InformationsquelleAutor Michael Buen

4

Ich denke, Sie wollen keine Berechnungen, wenn Sie wollen, Hiword /Hibyte oder die LoWord /Lobyte,
wenn ein System.Int32 startet bei Adresse 100 (so dass es sich in Adresse 100 bis 103), die Sie wollen, wie eine LoWord der zwei bytes beginnend mit der Adresse 100 und 101 und Hiword ist die Adresse 102 und 103.

Dies kann erreicht werden durch die Klasse BitConverter. Diese Klasse tut nichts mit den bits, es nutzt nur die Adressen zur Rücksendung der angeforderten Wert.

Als die Größe von Typen wie int /long sind unterschiedlich je nach Plattform und WORD und DWORD sind ein bisschen verwirrend, ich benutze den System-Typen System.Int16/Int32/Int64. Niemand wird jemals irgendwelche Probleme haben, zu erraten, die Anzahl der bits, die in einem System.Int32.

Mit BitConverter können Sie konvertieren eine ganze Zahl in das array von bytes ab, die Lage und wandeln Sie ein array von bytes von der richtigen Länge für die entsprechenden integer. Keine Berechnungen notwendig und kein bit ändern,

Angenommen, Sie haben ein System.Int32 X (das ist ein DWORD-in alten Begriffen)
```
LOWORD: System.Int16 y = BitConverter.ToInt16(BitConverter.GetBytes(x), 0);
HIWORD: System.Int16 y = BitConverter.ToInt16(BitConverter.GetBytes(x), 2);
```
Das schöne ist, dass dies funktioniert mit allen Längen, die Sie nicht haben, um die Funktionen kombinieren, wie LOBYTE und HIORD die Dritte byte:
```
HIByte(Hiword(x)) will be like: BitConverter.GetBytes(x)[3]
```
InformationsquelleAutor Harald Coppoolse

Andere Alternative

    public class Macro
    {
        public static short MAKEWORD(byte a, byte b)
        {
            return ((short)(((byte)(a & 0xff)) | ((short)((byte)(b & 0xff))) << 8));
        }

        public static byte LOBYTE(short a)
        {
            return ((byte)(a & 0xff));
        }

        public static byte HIBYTE(short a)
        {
            return ((byte)(a >> 8));
        }

        public static int MAKELONG(short a, short b)
        {
            return (((int)(a & 0xffff)) | (((int)(b & 0xffff)) << 16));
        }

        public static short HIWORD(int a)
        {
            return ((short)(a >> 16));
        }

        public static short LOWORD(int a)
        {
            return ((short)(a & 0xffff));
        }
    }

InformationsquelleAutor jv_

Ich diese 2 Funktion...

    public static int GetHighint(long intValue)
    {
        return Convert.ToInt32(intValue >> 32);
    }

    public static int GetLowint(long intValue)
    {
        long tmp = intValue << 32;
        return Convert.ToInt32(tmp >> 32);
    }

InformationsquelleAutor user3494684

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.