Array creation with constants in c#

Question

I'm sure this has been asked here already but I can't locate the answer...
In c we have this:

#define COMMAND_ARGUMENTS_SIZE (3)
typedef struct
{
    unsinged char opcode; 
    unsigned char arguments[COMMAND_ARGUMENTS_SIZE];
} Command;

In c# we'd like this:

struct Command
{
    byte opcode;
    byte arguments[...];
}

The array sizes are in a state of flux and we have them used across several files. We'd like to keep the #define (but we know we can't....). This is a port and we're not about to do major rewrites.

Eric Lippert · Accepted Answer · 2011-06-08 23:07:04Z

4

Mark the type as "unsafe" and use a fixed size buffer.

unsafe struct Command 
{ 
  const int CommandArgumentsSize = 3;
  byte opcode;
  fixed byte arguments[CommandArgumentsSize];
}

It is easy to get confused between the "fixed" declaration and the "fixed" statement. See my article on the subject if this is confusing.

Alternatively, if you only have three of them then I'd be inclined to:

struct Command 
{ 
  byte opcode;
  byte arg1;
  byte arg2;
  byte arg3;
}

Easy peasy, no messing around with crazy pointers. If there are only three of them, that's a good solution; if it's a 1000 byte struct then that might not be so hot.

edited Jun 8, 2011 at 23:07

answered Jun 8, 2011 at 22:23

Eric Lippert

663k185 gold badges1.3k silver badges2.1k bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

svick Over a year ago

fixed has to be before the type, not after.

Gio Over a year ago

I'm not thrilled about 'fixed' as it leaves me with 'unsafe' which I then have to propogate up the chain, and right now the guy who signs my check is looking at me funny because he wants it done N O W.

carlosfigueira · Accepted Answer · 2011-06-08 22:46:13Z

2

You can define a constants utility class to hold the "define"-like directives in C#:

public static class Constants
{
    public const int CommandArgumentsSize = 3;
}

struct Command
{
    byte opcode;
    byte[] arguments = new byte[Constants.CommandArgumentsSize];
}

edited Jun 8, 2011 at 22:46

answered Jun 8, 2011 at 22:24

carlosfigueira

87.7k14 gold badges137 silver badges176 bronze badges

5 Comments

Gio Over a year ago

This seems to make life simpler.. however you need a byte[] for 'arguments'.

carlosfigueira Over a year ago

You don't really need the class, but I think it helps keeping things in place. And thanks for the byte/byte[] type, I've fixed it.

George Mauer Over a year ago

@Gio - What do you mean you don't need a class for consts? You can't put them directly in the namespace nor outside the namespace.

carlosfigueira Over a year ago

You can put the constant in the same class/struct where it's used (in this case, Command), instead of having a class just for the constants. If this is the only place where it's going to be used, then I'd actually say it's better to do that than inside a "Constants" class. But if it's going to be used in multiple places, I'd prefer to have it in one place where we can easily change.

Mike Caron Over a year ago

Personally, I would put the constant where it is most logical: In this case, it would be in Command, and I'd name the constant ArgumentsSize, thus allowing me to refer to it as Command.ArgumentsSize.

George Mauer · Accepted Answer · 2011-06-08 22:23:58Z

0

Use a static class

static class Constants 
{
  public const int DEFAULT_ARRAY_SIZE = 20;
}

It's generally a better idea to encapsulate such knowledge but something like this would not be awful as long as you don't put more than a few constants in there.

answered Jun 8, 2011 at 22:23

George Mauer

123k140 gold badges400 silver badges632 bronze badges

Comments

Richard Schneider · Accepted Answer · 2011-06-08 22:26:07Z

0

Instead of #define use a public const in C#

 struct Command {
    public const int ArgumentSize = 3;
    byte opcode;
    byte[] arguments;
 }

Note: that you have "allocate" the byte array. I would use a class that preallocates:

 class Command {
    public const int ArgumentSize = 3;
    public byte opcode;
    public byte[] arguments = new byte[ArgumentSize];
 }

answered Jun 8, 2011 at 22:26

Richard Schneider

35.5k9 gold badges59 silver badges74 bronze badges

Comments

svick · Accepted Answer · 2011-06-08 22:29:19Z

0

You can do this:

unsafe struct Command
{
    const int CommandArgumentSize = 3;

    byte opcode;
    fixed byte arguments[CommandArgumentSize];
}

You have to allow unsafe code in your compiler to do this.

If you only want to use it for communication with some unmanaged code, using [MarshalAs(UnmanagedType.ByValArray)] should do the trick too.

answered Jun 8, 2011 at 22:29

svick

247k54 gold badges405 silver badges535 bronze badges

Collectives™ on Stack Overflow

Array creation with constants in c#

5 Answers 5

2 Comments

5 Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

2 Comments

5 Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related