I’ve been battling this problem for months.  I’ve found several suggestions to resolve the issue.  Connecting by IP address rather than name, disabling LLMNR, putting the SQL server in the HOSTS file, which of course should have the same effect as using the IP address.  None of these worked.  I finally started looking at why the RDP would be slow instead of looking at it from the SQL side.  I quickly ran across this post:  http://everydaynerd.com/microsoft/windows-7-slow-remote-desktop-rdp-fix and tried it.  The results were immediate. 

The solution (at least for me) was to disable TCP Autotuning.  To do this go to command prompt with as the administrator.

Click on Start -> All Programs ->Accessories

Right Click Command Promt

Click Run As Administrator

Type netsh interface tcp set global autotuninglevel = disabled

You should receive and Ok. message

To verify that the change was successful type netsh interface tcp show global

You should see that Redceive Window Atuo-Tuning Level is disabled.

 List<string> myList = new List<string>();
myList.Add(“C”);
myList.Add(“B”);
myList.Add(“Z”);
myList.Add(“A”);
myList.Sort();
foreach (string str in myList)
{
    Console.WriteLine(str);
}

 The above code will output the letters in alphabetical order.  But what if your list is for a custom class rather than for a standard data type.  Then we have to use some of the more advanced features of the List.Sort Method.  So lets say we have a class, in this case called ContactInfo, which has seveal properties to hold information about contacts. 

class ContactInfo
{
    public string LastName{ get; set; }
    public string FirstName { get; set; }
    public string MiddleInitial { get; set; }
    public string Phone { get; set; }
    public string EMail { get; set; }
} 

Now we create a list so that we can work with several contacts.

List<ContactInfo> ContactList = new List<ContactInfo>();

 Now we add information to the List.  This would generally be done with a database call rather than hand coded information of course.

ContactInfo ci = new ContactInfo();
    ci.FirstName = “John”;
    ci.LastName = “Doe”;
    ci.MiddleInitial = “C”;
    ci.Phone = “555-1212″;
    ci.EMail = “John.Doe@SomeDomain.com”;
    ContactList.Add(ci);
    ci = new ContactInfo();
    ci.LastName = “Smith”;
    ci.FirstName = “Jane”;
    ci.MiddleInitial = “F”;
    ci.Phone = “111-2222″;
    ci.EMail = “jsmith@anotherdomain.com”;
    ContactList.Add(ci);
  // … Add as many contacts as you like

So now to the sorting:

// Sort By Last name
ContactList.Sort(delegate(ContactInfo c1, ContactInfo c2) { return c1.LastName.CompareTo(c2.LastName); });

// Sort by Phone Number
ContactList.Sort(delegate(ContactInfo c1, ContactInfo c2) { return c1.Phone.CompareTo(c2.Phone); });

You can obviously use this method for any parameter of the custom class the list is based on.  This allows you to use your list in a listbox or other container and sort the data as you choose on the fly.

I decided that I didn’t want my application to have this problem, but I still wanted to be able to save the position.  I searched the Internet for anything that would work and found many ways to save the position, but none of them seemed to take multiple monitors into account or more precisely an inconsistent monitor setup).  So after many tries I finally came up with a method that worked.  In this method I am storing the position in an INI file, but it could be stored in the registry or an XML file as easily.

I easily found code that would allow me to specify which screen to start on, but using that code, the coordinate reference assumes that 0,0 is the top left of the specified monitor.  When getting the coordinates of the form I could find nothing that would give me the coordinates based on the monitor in use.  Every method I found gave coordinates based on 0,0 being the top left of the primary monitor.  So if I positioned the form in the middle of my left monitor and exited I would store an X position of -600 (600 pixels to the left of the primary monitor), but when loading the form I need to tell it to move 424 pixes to the right from its origin on the secondary monitor.  All very confusing.

The key was to determine the bounds of the monitor used.  This uses the same coordinates referenced in the forms location so a 1024×768 monitor to the left of the primary monitor (also 1024×768) would have it’s upper left corner be -1024,0.  We can subtract the Bounds coordinates from the saved coordinates to find the coordinates relative to the top left corner of the monitor used.  I also check to verify that the position stored is within the bounds of the selected monitor, and if not display the form in the upper left corner of the selected monitor.  This way the form is never displayed in a position where it can not be seen.

Another problem with the code I found for specifying which screen to start on was that it did not verify the existence of that screen before trying to change to it.  So if a monitor was disconnected you would end up with an error.  Storing the selected monitor wound up being a bit more of a challenge than expected.  The property Screen.DisplayName pads the end of the string with a number of hidden characters.  Trimming off the extra characters solved my problems with this section, but it was annoying to track down.

I hope this helps anyone else who might be trying to achieve the same effect.

The following code goes in the Form_Load procedure
‘ Multi Monitor Aware – Restore Postition to last Used
Dim posScreen As Integer
Dim posX As Integer
Dim posY As Integer
Dim screen As Screen
‘ Read the previous screen used from the INI file
posScreen = Val(ReadIni(File, “Main”, “PosScreen”))
screen = screen.AllScreens(0)
‘ Verify the Specified screen exists, if so then use it
If screen.AllScreens.Length > posScreen + 1 Then
screen = screen.AllScreens(0)
Else
screen = screen.AllScreens(posScreen)
End If
‘ Read the Position from the INI File
posX = Val(ReadIni(File, “Main”, “PosX”))
posY = Val(ReadIni(File, “Main”, “PosY”))
Dim pt As New Point(posX, posY)
If screen.Bounds().Contains(pt) Then
pt.X = posX – screen.Bounds().X
pt.Y = posY – screen.Bounds().Y
Else
pt.X = 0
pt.Y = 0
End If
Me.StartPosition = FormStartPosition.Manual
Me.Location = screen.Bounds.Location + pt

The following code goes in the Form_FormClosing procedure
‘ Save Screen Position
For i As Integer = 0 To
screen.AllScreens().Length – 1
If stringtoasc(screen.AllScreens(i).DeviceName.ToString) _
= stringtoasc(screen.FromControl(Me).DeviceName.ToString) Then
WriteIni(File, “Main”, “PosScreen”, i)
End If
Next
WriteIni(File, “Main”, “PosX”, Me.Location.X)
WriteIni(File, “Main”, “PosY”, Me.Location.Y)

*Note the ReadINI and WriteINI functions are in a module not shown here.  As they are not really a major part of the issue with positioning the form.  If anyone would like to see the related code I will be happy to post it, however there are several variations available by searching the Internet.

I suppose I should explain the hardware involved to give the full picture.  The older server is a Pentium 4 server running Windows 2003.  The system has an external drive array with 16 drives.  The external drive system is configured as 4 RAID 5’s each about 1.5 TB.  This array is connected to the server via a SCSI adapter. 

The new server is a Xeon Quad Core also running Windows 2003 and has 24 driver bays internal to the server chasis.  The drives in the new server are configures with the first 16 drives as a RAID 60 (two 8 drive raid 6’s striped together for better performance) this provides about 11.2 TB, a 6 drive RAID 5 (4.5 TB) and 2 drives in a RAID 1 for the O/S.  The reason for the odd splitting is that I used two RAID controllers to connect all of the drives, a 16 port and an 8 port.  All of the drives in both systems are SATA II.

I decided to take the network cards out of the loop assuming that this was where my bottleneck was, although I never saw network utilization on the cards in question going above 10%.  I moved the SCSI card from the old server to the new and attached the external drive array to the new server.  This I assumed would give me a much faster transfer.  Unfortunately this has not been the case.  After 20 hours of copying only 650 GB have transferred to the new system. 

I’ve started testing some utilities that claim to improve copy speed (teracopy, fastcopy, totalcopy) and will post the results of the results of these tests here.  In the mean time it’s slow going.  Comments or suggestions?

————–

Update:

Well I tried a few of the copy programs I mentioned above.  I finally wound up using FastCopy.  There is one confusing part in that program depeding on if you include a trailing \ or not will affect what is copied, but this is documented as a feature, not a bug and overall the program did an excellent job.  One very nice feature of it is to queue copy jobs so that they will start one after the other.