C#

martin_hughes wrote:

Aha, says I, multiple threads can speed this up.

martin_hughes wrote:

could too many threads in this situation lead to much slower performance as they all vie for time?

Pete O`Hanlon wrote:

Notepad uses a fixed width font

private void PrintTextFileHandler(object sender, PrintPageEventArgs ppeArgs)<br />
        {<br />
            //Get the Graphics object<br />
            Graphics g = ppeArgs.Graphics;<br />
            float linesPerPage = 0;<br />
            float yPos = 0;<br />
            int count = 0;<br />
            //Read margins from PrintPageEventArgs<br />
            float leftMargin = ppeArgs.MarginBounds.Left;<br />
            float topMargin = ppeArgs.MarginBounds.Top;<br />
            string line = null;<br />
            //Calculate the lines per page on the basis of the height of the page and the height of the font<br />
            linesPerPage = ppeArgs.MarginBounds.Height / verdana10Font.GetHeight(g);<br />
            //Now read lines one by one, using StreamReader<br />
            while (count < linesPerPage &&<br />
            ((line = reader.ReadLine()) != null))<br />
            {<br />
                //Calculate the starting position<br />
                yPos = topMargin + (count *<br />
                verdana10Font.GetHeight(g));<br />
                //Draw text<br />
                g.DrawString(line, verdana10Font, Brushes.Black,<br />
                leftMargin, yPos, new StringFormat());<br />
                //Move to next line<br />
                count++;<br />
            }<br />
            //If PrintPageEventArgs has more pages to print<br />
            if (line != null)<br />
            {<br />
                ppeArgs.HasMorePages = true;<br />
            }<br />
            else<br />
            {<br />
                ppeArgs.HasMorePages = false;<br />
            }<br />
        }

Dio22 wrote:

"Attempted to read or write protected memory. This is often an indication that other memory is corrupt."

ForkOffandDie wrote:

if calling Dispose() results in an implicit call to Close()

try
{
    if (table != null)
    {
        OleDbConnection connection;
        try
        {
            connection = new OleDbConnection();
            connection.Open();

            OleDbCommand command;
            try
            {
                command = connection.CreateCommand();
                command.CommandText = "SELECT obj From " + table.Alias;

                OleDbDataReader reader;
                try
                {
                    reader = command.ExecuteReader();
                    while (reader.Read())
                    {
                        container.Add(new Feature((xx)reader.Getxx(0)));
                    }
                }
                finally
                {
                    if (reader != null)
                    {
                        ((IDisposable)reader).Dispose();
                    }
                }
            }
            finally
            {
                if (command != null)
                {
                    ((IDisposable)command).Dispose();
                }
            }
        }
        finally
        {
            if (connection != null)
            {
                ((IDisposable)connection).Dispose();
            }
        }
    }
}
catch (Exception)
{
    MessageBox.Show("There was a GPS Error");
}

1. The runtime searches the array for the first protected block that:
   
   • Protects a region that includes the currently executing instruction, and
     
   • Contains an exception handler or contains a filter that handles the exception.
     
   
   
2. If a match occurs, the runtime creates an Exception object that describes the exception. The runtime then executes all finally or fault statements between the statement where the exception occurred and the statement handling the exception. Note that the order of exception handlers is important: the innermost exception handler is evaluated first. Also note that exception handlers can access the local variables and local memory of the routine that catches the exception, but any intermediate values at the time the exception is thrown are lost.
   
   
   If no match occurs in the current method, the runtime searches each caller of the current method, and it continues this path all the way up the stack. If no caller has a match, the runtime allows the debugger to access the exception. If the debugger does not attach to the exception, the runtime raises the UnhandledException event. If there are no listeners for the UnhandledException event, the runtime dumps a stack trace and ends the program.

ForkOffandDie wrote:

What would have priority over a thrown exception such that it HAD to process before a catch was allowed to handle the Exception?

Pete O`Hanlon wrote:

ms.Position = 0;