C#

<?xml version="1.0" encoding="utf-8" ?>
  <configuration>
    <configSections>
      <sectionGroup name="Groups" >
        <section name="Group1" type="System.Configuration.NameValueSectionHandler" />
        <section name="Group2" type="System.Configuration.NameValueSectionHandler" />
        <section name="Group3" type="System.Configuration.NameValueSectionHandler" />
      </sectionGroup>
      <sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
      </sectionGroup>
    </configSections>
    <Groups>
      <Group1>
        <add key="System 1" value="192.168.0.3" />
      </Group1>
      <Group2>
        <add key="System 2" value="192.168.0.1" />
        <add key="System 3" value="192.168.0.2" />
      </Group2>
      <Group3>
        <add key="key1" value="value1" />
        <add key="key2" value="value2" />
      </Group3>
    </Groups>
    <userSettings>
        <setting name="LastGroup" serializeAs="String">
          <value>Group1</value>
        </setting>
    </userSettings>
</configuration>

<GroupManager>
    <Groups>
        <Group GroupName="Group 1">
            <System Name="System 1">192.168.0.1</System>
        </Group>
        <Group GroupName="Group 2">
            <System Name="System 2">192.168.0.2</System>
        </Group>
    </Groups>
</GroupManager>

byte[] data = new byte[size];
[...].unsafe{
  fixed (byte* ptr = data) {
    [...]
    for (int i = 0; i < size; i++)
      ptr[i] = 128;
    [...]
  }
}

byte[] data = new byte[size];
[...].for (int i = 0; i < size; i++)
   data[i] = 128;

byte* ptr = data;
byte* ptrEnd = data;
ptrEnd += (size - (size % 10));
while (ptr != ptrEnd)
{
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
}
ptrEnd += (size % 10);
while(ptr != ptrEnd)
{
    *ptr = 128; ptr++;
}

*(++ptr) = 128;   // Maybe this?
*(ptr++) = 128;   // Or was it this?

Array.Copy(data, 0, length, data, length, length);

Kevin13 wrote:

The C# returns between 30 and 45 ms and the C/C++ a stable 4.2 ms.

 

Is there anything I can do with my C# code to speed it up?

Bastard Programmer from Hell

Eddy Vluggen wrote:

You're comparing native code to an interpreted language

AspDotNetDev wrote:

It's compiled on the machine it is run on, making it possibly faster than pre-compiled code for a more generic architecture.

AspDotNetDev wrote:

My guess is that the C++ compiler is using some special optimization (e.g., MMX instructions, or loop unwinding) that the C# compiler didn't happen to implement for this scenario.

Bastard Programmer from Hell

Eddy Vluggen wrote:

Compiles to bytecode AFAIK, and runs in a VM.

Eddy Vluggen wrote:

No garbage-collector thread in the background, no framework at all.

AspDotNetDev wrote:

The DLL contains bytecode, but when (just before, actually) the DLL is run it gets compiled to native code.

AspDotNetDev wrote:

The garbage collector works in stages. It wouldn't slow down performance in general.

Bastard Programmer from Hell

class Program
{
    static List<String> numbersList = new List<string>();
    static void Main(string[] args)
    {
        int start = Environment.TickCount;
        while (Environment.TickCount - start < 5000)
        {
            numbersList.Add("Tick " + Environment.TickCount);
        }
        Console.WriteLine(numbersList.Count);
        Console.ReadKey();
    }
}

procedure Test1();
var start: dword;
    numbersList: TStringList;
begin
  numbersList := TStringList.Create();
  start := GetTickCount();
  while GetTickCount() - start < 5000 do
  begin
    numbersList.Add('Tick ' + IntToStr(GetTickCount()));
  end;
  WriteLn(numbersList.Count);
  numbersList.Clear;
  numbersList.Free;
end;

begin
  Test1();
  ReadLn();
end.  

procedure Test2();
const testSize = 10000000;
var start: dword;
    data : array[0..testSize] of byte;
    i    : integer;
begin
  start := GetTickCount();
  for i := 0 to testSize do
  begin
     data[i] := 128;
  end;
  WriteLn('Safe time ' +  IntToStr(GetTickCount() - start) + ' ms');
end;

procedure Test2();
const testSize = 10000000;
var start: dword;
    data : array[0..testSize] of byte;
begin
  start := GetTickCount();
  FillChar(data, SizeOf(data), 128);
  WriteLn('Safe time ' +  IntToStr(GetTickCount() - start) + ' ms');
end;

Bastard Programmer from Hell

interface IUndoableCommand {
 void Undo();
 void Redo();
}

class ItemRenameCommand : IUndoableCommand {
 string oldname, newname;
 INamedModel Model { get; set; }
 
 ItemRenameCommand(INamedModel model, string oldname, string newname) {
  this.oldname = oldname; this.newname = newname;
  Model = model;
 }

 void Undo() { Model.Name = oldname; }
 void Redo() { Model.Name = newname; }
}

class MainForm : Form {
 ...
 void TreeNodeRenamed(object sender, NodeRenameEventArgs e){
  IUndoableCommand renameCommand = new ItemRenameCommand(treeViewModel, e.OldName, e.NewName);
  undoStack.Push(renameCommand);
 }

 Stack<IUndoableCommand> undoStack, redoStack;
}