C#

hammerstein05 wrote:

Could it be that I'm overloading my socket somehow

unsafe
{
   msghdr = (MSG_HDR *)&mt_buff[0];
}

public unsafe void DoIt() {...}

public void ModifyThisInt(ref int i)
{
    i = 10;
}

int i = 0;
ModifyThisInt(ref i); 
Console.WriteLine(i); // "10"

Judah Himango wrote:

msghdr = (MSG_HDR *)&xmt_buf[0];

struct MessageHeader_t
{
	unsigned char	MessageFormat;
	unsigned char	MessageLength;
	unsigned char	MessageType;
	unsinged char	MessageFlags[6];
	unsigned char	HeaderLength;
} MSG_HDR;

Dewald wrote:

msghdr = (MSG_HDR *)&xmt_buf[0];

fixed ( MSG_HDR* msghdr = &xmt_buf ) // assumming xmt_buf is an array, this will take a pointer to the first element in the array
{
    // use msghdr in here
}

struct MessageHeader
{
	byte	MessageFormat;
	byte	MessageLength;
	byte	MessageType;
	byte[]	MessageFlags = new byte[6];
	byte	HeaderLength;
}

/// <summary>
/// Defines the header of a message.
/// </summary>
public class MessageHeader
{
   private byte format;
   private byte length;
   private byte type;
   private byte[] flags;
   private byte headerLength;

   /// <summary>
   /// Constructs a new default message header instance.
   /// </summary>
   public MessageHeader()
   {
   }

   /// <summary>
   /// Constructs a new message header with all the data supplied up front.
   /// </summary>
   public MessageHeader(byte format, byte length, byte type, byte[] flags, byte headerLength)
   {
       // Verify flags isn't null.
       if(flags == null)
       {
          throw new ArgumentNullException("flags");
       }

       // Verify flags is 6 elements long
       if(flags.Length != 6)
       {
          throw new ArgumentException("Flags must be 6 elements in length.");
       }

       this.format = format;
       this.length = length;
       this.type = type;
       this.flags = flags;
       this.headerLength = headerLength;
   }

   /// <summary>
   /// Gets or sets the format of the message header.
   /// </summary>
   public byte Format
   {
      get { return this.format; }
      set { this.format = value; }
   }

   /// <summary>
   /// Gets or sets the length of the message header.
   /// </summary>
   public byte Length
   {
      get { return this.length; }
      set { this.length = value; }
   }

   /// <summary>
   /// Gets or sets the flags of the message header.
   /// </summary>
   public byte[] Flags
   {
      get { return this.flags; }
      set 
      { 
         if(value == null)
         {
            throw new ArgumentNullException("flags");
         }
         if(value.Length != 6)
         {
            throw new ArgumentException("flags must be 6 elements in length.");
         }

         this.flags = value; 
      }
   }

   /// <summary>
   /// Gets or sets the header length of the message header.
   /// </summary>
   public byte HeaderLength
   {
      get { return this.headerLength; }
      set { this.headerLength = value; }
   }
}

MessageHeader header = new MessageHeader();
header.Flags = new byte[] { 5, 240, 6, 29, 60, 152 };

Dewald wrote:

BTW - I like your blog.

Dewald wrote:

What would help is if you could give me an example of a byte array being passed as a reference variable to a function.

static void ProcessArr(ref byte[] paramArr)<br />
{<br />
        for (int i=0; i<paramArr.Length; i++)<br />
        {<br />
                // Do something that changes the value of paramArr[i]<br />
        }<br />
}

<br />
byte[] byteArr = { 0, 1, 2, 3, 4 };<br />
ProcessArr(ref byteArr);<br />

byte[] myBytes = { 5, 10, 15 };
FillItAllWith7s(myBytes);
// myBytes is now filled with all 7s.

...

void FillItAllWith7s(byte[] bytesToModify)
{
    for(int i = 0; i < bytesToModify.Length; i++)
    {
        bytesToModify[i] = 7;
    }
}

byte[] myBytes = {1, 2, 3};
SetToNull(ref myBytes);
// myBytes is now null! We actually changed the myBytes to point to something else!

...

void SetToNull(ref byte[] bytesToModify)
{
   bytesToModify = null;
}