barcode printing vb.net Part V in Visual C#

Making PDF-417 2d barcode in Visual C# Part V

[DllImport("Kernel32", ExactSpelling = true, SetLastError = true)] [return: MarshalAs(UnmanagedType.Bool)] private static extern Boolean SetThreadPriority( SafeWaitHandle hthread, ThreadBackgroundgMode mode); // http://msdn.microsoft.com/en-us/library/aa480216.aspx [DllImport("Kernel32", SetLastError = true, EntryPoint = "CancelSynchronousIo")] [return: MarshalAs(UnmanagedType.Bool)] private static extern Boolean CancelSynchronousIO(SafeWaitHandle hThread); }

And here is code showing how to use it:

public static void Main () { using (ThreadIO.BeginBackgroundProcessing()) { // Issue low-priority I/O requests in here (eg: calls to BeginRead/BeginWrite) } }

You tell Windows that you want your thread to issue low-priority I/O requests by calling ThreadIO s BeginBackgroundProcessing method . Note that this also lowers the CPU scheduling priority of the thread . You can return the thread to making normal-priority I/O requests (and normal CPU scheduling priority) by calling EndBackgroundProcessing or by calling Dispose on the value returned by BeginBackgroundProcessing (as shown above via C# s using statement) . A thread can only affect its own background processing mode; Windows doesn t allow a thread to change the background processing mode of another thread . If you want all threads in a process to make low-priority I/O requests and have low CPU scheduling, you can call BeginBackgroundProcessing, passing in true for the process parameter . A process can only affect its own background processing mode; Windows doesn t allow a thread to change the background processing mode of another process . Important As a developer, it is your responsibility to use these new background priorities to

allow the foreground applications to be more responsive, taking care to avoid priority inversion. In the presence of intense normal-priority I/Os, a thread running at background priority can be delayed for seconds before getting the result of its I/O requests . If a low-priority thread has grabbed a thread synchronization lock for which the normal-priority thread is waiting, the normal-priority threads might end up waiting for the background-priority thread until the low-priority I/O requests are completed . Your background-priority thread does not even have to submit I/Os for the problem to happen . So using shared synchronization objects between normal- and background-priority threads should be minimized (or eliminated if possible) to avoid these priority inversions where normal-priority threads are blocked on locks owned by background-priority threads .

In The APM and Compute-Bound Operations section earlier in this chapter, I showed how to use the APM to perform a compute-bound operation . In this section, I show how to do the opposite: use a Task to perform an I/O-bound operation . In the System.Threading.Tasks namespace, there is a class called TaskFactory . This class was discussed in 26 . However, this class offers a FromAsync method, which I did not discuss in 26 . This method accepts four arguments and returns a reference to a Task object . The four arguments are a BeginXxx method, an EndXxx method, an Object state, and an optional TaskCreationOptions10 value . So instead of initiating an asynchronous operation like this:

WebRequest webRequest = WebRequest.Create("http://Wintellect.com/"); webRequest.BeginGetResponse(result => { WebResponse webResponse = null; try { webResponse = webRequest.EndGetResponse(result); Console.WriteLine("Content length: " + webResponse.ContentLength); } catch (WebException we) { Console.WriteLine("Failed: " + we.GetBaseException().Message); } finally { if (webResponse != null) webResponse.Close(); } }, null);

you can turn it into a Task, and then use it with the rest of the Task infrastructure like this:

WebRequest webRequest = WebRequest.Create("http://Wintellect.com/"); Task.Factory.FromAsync<WebResponse>( webRequest.BeginGetResponse, webRequest.EndGetResponse, null, TaskCreationOptions.None) .ContinueWith(task => { WebResponse webResponse = null; try { webResponse = task.Result; Console.WriteLine("Content length: " + webResponse.ContentLength); } catch (AggregateException ae) { if (ae.GetBaseException() is WebException) Console.WriteLine("Failed: " + ae.GetBaseException().Message); else throw; } finally { if (webResponse != null) webResponse.Close(); } });

method has additional overloads that allow you to pass up to three parameters to a BeginXxx method . If you need to call a BeginXxx method that takes more than three parameters, then there is a FromAsync overload that accepts an IAsyncResult parameter; you call the BeginXxx method yourself and its return value here . Avoid this overload if you can because it is less efficient than the overloads of FromAsync that do not take an IAsyncResult .