Zuweisen von Werten zu einer öffentlichen byte-array in eine Zeile C#

Arbeite ich mit einem öffentlichen byte-array und möchte Werte zuweisen, wie ich das zuweisen von arrays innerhalb einer Methode, ich.e

byte[] foo = {0x32, 0x00, 0x1E, 0x00};

aber wenn ich die Werte definieren, die ich gezwungen bin zu tun,

foo[0] = 0x32;
foo[1] = 0x00;
foo[2] = 0x1E;
foo[3] = 0x00;

Wenn ich das erste Beispiel VS gibt einen Fehler, "Nur Belegung, call -, increment -, decrement, warten, und neue Objekt-Ausdrücke können verwendet werden, wie eine Aussage"

Wenn es hilft jedem, das array ist immer 4 bytes.

mein code

public byte[] SetSpeed = new byte[4];
private void trackBar1_Scroll(object sender, EventArgs e)
{
    if (trackBar1.Value == 0)
    {
        try
        {
            stop = true;
            UpdateSThread.Abort();
            Thread.Sleep(350);
        }
        catch { }
        SetSpeed = {0x00,0x00,0x00,0x00};
        WriteMem(GetPlayer() + STATUS_OFFSET, SetSpeed);
        label1.Text = "Normal";              
    }
}

Bitte schreiben Sie einen kurzen, aber komplett Beispiel mit dem scheitern. Ich würde erwarten, dass das, was Sie gegeben haben in Ordnung zu sein - aber nicht, wenn Sie nur die Zuordnung zu foo ohne Sie zu deklarieren.
Ihre erste Beispiel kompiliert (VS2012)
Haben Sie immer noch nicht angezeigt, der code würde nicht kompilieren. Ich Verdacht Sie versuchten SetSpeed = { 0x00, 0x00, 0x00, 0x00 } die nicht das gleiche wie Ihr original-Beispiel überhaupt. Zusätzlich, Sie haben nicht deutlich gemacht, ob Sie wirklich wollen, erstellen Sie ein neues array oder ob Sie wollen einfach nur mutieren die vorhandenen array.
das Beispiel habe ich jetzt was nicht kompilieren.
Endlich. Das ist es, was sollte wurden in der Frage mit zu beginnen.

InformationsquelleAutor user2340475 | 2013-08-19

bytearray c#public

Ihre erste Beispiel ist gut, aber es darf nur verwendet werden, in einer Erklärung. Die Elemente müssen implizit Cabrio auf den Typ des Elements. Die Größe hängt von der Anzahl der Elemente gegeben.

byte[] foo = { 0x32, 0x00, 0x1E, 0x00 };

Alternativ können Sie auch d diese

byte[] foo = new byte[4];
foo[0] = 0x32;
foo[1] = 0x00;
foo[2] = 0x1E;
foo[3] = 0x00;

wird, wie oben angegeben, die syntax, die Sie verwenden möchten, können nur verwendet werden, in einer Erklärung. so versuchen wie diese.

public byte[] SetSpeed;
private void trackBar1_Scroll(object sender, EventArgs e)
{
    if (trackBar1.Value == 0)
    {
        try
        {
            stop = true;
            UpdateSThread.Abort();
            Thread.Sleep(350);
        }
        catch { }

        //note it will always create a new array
        SetSpeed = new byte[]{0x00,0x00,0x00,0x00}; 
        WriteMem(GetPlayer() + STATUS_OFFSET, SetSpeed);
        label1.Text = "Normal";              
    }
}

Es gibt keine müssen, um dies zu tun, obwohl - die original-code kompiliert werden, sowieso.
Danke, das funktioniert, ich denke, ich stieß zu vage, die öffentlich-tag relevant war, aber entfernt. keine Sorge, ich habe meine Antwort

InformationsquelleAutor Ehsan

6

Kann man nur die form, wo Sie nicht angeben new wenn Sie deklarieren eine variable. So, das ist in Ordnung:
```
byte[] x = { 1, 2, 3 };
```
Aber das ist es nicht:
```
byte[] x;
x = { 1, 2, 3 };
```
Stattdessen müssen Sie etwas wie:
```
byte[] x;
x = new byte[] { 1, 2, 3 };
```
Oder für Fälle, in denen Typ-Inferenz arbeiten, zu Ihren Gunsten, und Sie sind mithilfe von C# 3 oder höher verfügen, können Sie ein implizit typisiertes array:
```
string[] x;
x = new[] { "a", "b", "c" };
```
Jedoch, Sie wirklich brauchen, um zu entscheiden, ob Sie wollen zum erstellen eines neuen array, oder ob Sie möchten, mutieren die bereits vorhandenen array. Da man nur die Einstellung alle Werte auf 0, könnte man stattdessen verwenden:
```
Array.Clear(SetSpeed, 0, 4);
```
EDIT: Nun, die Frage enthält:

Möchte ich eine änderung der Werte in einem vorhandenen array

dann mit
```
SetSpeed = new byte[] { ... }
```
ist nicht entsprechende, ändern Sie den Wert von SetSpeed beziehen verschiedenen array.

Aktualisieren eines vorhandenen Arrays, könnten Sie entweder einfach mit den 4 separaten Anweisungen oder vielleicht extrahieren Sie es in eine separate Methode mit 4 Parametern. Es ist nicht wirklich klar, was die Werte sein werden, die macht es schwer, um Ihnen den bestmöglichen code.

Danke für die Ratschläge auf dem Array.Klar, die nächsten tick auf der Strecke bar, beginnen hinzufügen von Werten > 0.
Aber Sie müssen noch entscheiden, ob du ein neues array oder nicht. Irgendetwas anderes haben, eine Referenz auf das array bereits?
Es ist entweder Array.Clear(SetSpeed, 0, 4); oder ((IList<byte>)SetSpeed).Clear();.
Danke, behoben.
Nein das tut es nicht, wenn der Schieberegler bewegt sich 0, Ein thread gestartet wird, um eine Schleife aktualisieren Sie den Wert im Speicher, der Wert, der als SetSpeed, wenn wieder 0 der thread wird beendet und der Wert im Speicher wieder auf die 4 bytes von 0

InformationsquelleAutor Jon Skeet

Beispiel

byte[] foo = new byte[] { 0x32, 0x00, 0x1E, 0x00 };

nicht zuordnen von Werten zu einer bestehenden byte[]: eher, es ersetzt den Verweis durch einen Verweis auf eine neue byte[]. Ohne mehr Kontext kann dieser Ansatz (oder auch nicht), zum Beispiel, dass die öffentlichen byte[] werden kann, readonly, d.h.:

public byte[] Foo { get ; private set ; }

Was Sie tun können, ist die Verwendung der statischen überlastungen Array.Copy():

byte[] newBytes = GetSomeBytes() ;
Array.Copy( newBytes , Foo , Foo.Length ) ;

Oder Sie schreiben, könnte eine Erweiterung Methode (die vielleicht wrap Array.Copy sollten Sie dies wünschen):

public static CopyFrom<T>( this T[] target , int offset , params T[] source )
{
  foreach ( T value in values )
  {
     //Throws IndexOutOfRangeException if offset exceeds destination length
     target[offset++] = value ; 
  }
}

dem Sie Dinge tun, wie:

public byte[] Foo { get ; private set ; }
.
.
.
Foo.CopyFrom( 0, 1,2,3,4 ) ;
.
.
.
Foo.CopyFrom( 1, new byte[]{1,2} ) ;

InformationsquelleAutor Nicholas Carey

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.