vor initialisierung von listen mit einer classe

Hallo zusammen,

in C kann ich foldendes machen:

typedef struct
{
    uint8_t val;
    char iFlag;
    char* nameStr;
    uint8_t regNr;
}RegisterEigenschaften;

RegisterEigenschaften DFlist[] =
{
{0,0,"Status",DXLOCK},
{0,0,"AnalogValue,HIGHDEF},
{0,0,"PWM",SCHNECKEN_POWER},

in C# möchte ich die gleiche initialisierung mittels einer Liste machen. Ich weis wie das mit einer List<string> geht. Das steht überall im netz

anber wiemach obiges in C# folgendes geht nicht. Den weg mit Add kenn ich. Dafür muss ich aber jedesmal irgendwo den code aufrugen und die Werte einzeln eingen stellt auch nciht das problem. Was ich machen möchte ist eine einfache Tabelle, ohne jedesmal eingaben wie val=0; iflag=1 etc...

geht sowas oder ist das?

    class RegisterEigenschaften
   {
       public byte val;
       public byte iFlag;
       public string nameStr;
       public byte regNr;
   }

   class DFx
   {
   
       List<RegisterEigenschaften> DFlist= new List<RegisterEigenschaften>()
       { 
       {0,0,"Status",DXLOCK},
    {0,0,"AnalogValue,HIGHDEF},
    {0,0,"PWM",SCHNECKEN_POWER},

Viele Grüße,

Christoph

Hallo und willkommen,

in C# gibt es diese Art der (automatischen) Direktinitialisierung nicht, sondern es muß für die Klasse ein passender Konstruktor definiert sein (und dieser dann auch dafür aufgerufen werden):

List<RegisterEigenschaften> DFlist = new List<RegisterEigenschaften>()
{
  new RegisterEigenschaften(0, 0, "Status", DXLOCK),
  // ...
}

Da dies jedoch mehr Schreibarbeit (durch die Wiederholung des Klassennamens je Eintrag) ist, kann man seit C#-Version 9 es auch kürzer schreiben (s. C# 9.0: Target-typed New Expressions – Make Your Initialization Code Less Verbose):

List<RegisterEigenschaften> DFlist = new()
{
  new(0, 0, "Status", DXLOCK),
  // ...
}

Es gibt aber auch noch weitere Möglichkeiten, s. Objekt- und Auflistungsinitialisierer (C#-Programmierhandbuch).

Und um nicht explizit den Konstruktor für die Klasse schreiben zu müssen, gibt es das ebenfalls neuere Schlüsselwort record(auf deutsch Datensätze genannt):

record RegisterEigenschaften
(
    byte val,
    byte iFlag,
    string nameStr,
    byte regNr // Hier solltest du besser ein enum benutzen
);

Beachte die runden Klammern, anstatt der geschweiften sowie die Kommata - dies entspricht der direkten Angabe wie bei einer Konstruktordefinition.

PS: Du hast dich selbst zitiert - wolltest du deinen Eingangsbeitrag editieren?

Wenn ich einen Konstruktor und new verwende gehts...

Kann man das noch einfacher machen?

    class RegisterEigenschaften
   {
       RegisterEigenschaften(byte val,byte iFlag, string nameStr,byte regNr)
    {
        this.val=val;
        this.byte=byte;
        this.string nameStr=nameStr;
        this.regNr=regNr;
    }
    public byte val;
       public byte iFlag;
       public string nameStr;
       public byte regNr;
   }

   class DFx
   {
   
       List<RegisterEigenschaften> DFlist= new List<RegisterEigenschaften>()
       { 
       {new RegisterEigenschaften(0,0,"Status",DXLOCK)},
    {new RegisterEigenschaften(0,0,"AnalogValue",HIGHDEF)},
    {new RegisterEigenschaften(0,0,"PWM",SCHNECKEN_POWER)},

In der aktuellen Version von C# (12.0) kann man das z.B. so machen:

enum DX
{
    DXLOCK,
    HIGHDEF,
    SCHNECKEN_POWER
}

// primärerer Constructor: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/tutorials/primary-constructors 
class RegisterEigenschaften(byte val,byte iFlag, string nameStr,DX regNr)
{ }
 
class DFx
{
    // collection expression: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-12#collection-expressions
    List<RegisterEigenschaften> DFlist= [
        new(0,0,"Status", DX.DXLOCK ),
        new(0,0,"AnalogValue", DX.HIGHDEF),
        new(0,0,"PWM", DX.SCHNECKEN_POWER),
    ];
}

In dem Fall kann man RegisterEigenschaften als record definieren.

Dann hast Du a) die Primary Ctor Funktionalität, wie auch b) die Eigenschaften eines immutables.
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/record

PS: wie Du C# Code schreibst zeigt, dass Du allgemein mit den Konventionen und Funktionalitäten (zB Felder vs Eigenschaften) nicht ganz vertraut bist.
Common C# code conventions

Was genau meinst du mit felder und eigenschaften?

Felder (C#-Programmierhandbuch)

Eigenschaften (C#-Programmierhandbuch)

Ich finde, eine kurze Google-Recherche kann man erwarten.

Das sind Felder:

 public byte val;
 public byte iFlag;
 public string nameStr;
 public byte regNr;

Aber...

• Felder sind i.d.R. private, weil sie Datenhalden darstellen und nur in ganz gewissen Use Cases Public sein sollten
• Schreibt man Public Felder wenn dann Groß
• Im Endeffekt wendest Du C++ Namensgewohnheiten auf C# an

Als Eigenschaften mit C# Regeln wäre das

 public byte Value { get; set; }
 public byte Flag { get; set; }
 public string Name { get; set; }
 public byte RegNr { get; set; }

Felder sehen aus wie Eigenschaften, haben zur Runtime aber eine völlig andere Funktionsweise.

Der Name der Klasse suggeriert für mich jedoch ein Immutable, sodass ein record das richtige wäre, oder eben die Eigenschaften statt set auf ein init.

Im Endeffekt sind Dir die C# Funktionsweisen und Schreibweisen offenbar unklar, sonst würde womöglich das Thema gar nicht existieren. Haben wir alle lernen müssen.

Investier einfach mal ne Stunde in die ersten Seiten der Docs, und Du kennst 80% der wichtigsten Regeln und Funktionen.