WorkItem.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / fx / src / xsp / System / Web / Util / WorkItem.cs / 1 / WorkItem.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web.Util { 
 
    using System.Runtime.InteropServices;
    using System.Security.Permissions; 
    using System.Threading;

//
// Support for positing of work items to a different thread 
//
 
 
/// 
///    [To be supplied.] 
/// 
public delegate void WorkItemCallback();

 
/// 
///    [To be supplied.] 
///  
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)] 
public class WorkItem {

    private static bool _useQueueUserWorkItem = true;
    private static WaitCallback _onQueueUserWorkItemCompletion = new WaitCallback(OnQueueUserWorkItemCompletion); 

 
    ///  
    ///    [To be supplied.]
    ///  

    [SecurityPermission(SecurityAction.Demand, Unrestricted=true)]
    public static void Post(WorkItemCallback callback) {
#if !FEATURE_PAL // ROTORTODO 
        if (Environment.OSVersion.Platform != PlatformID.Win32NT)
            throw new PlatformNotSupportedException(SR.GetString(SR.RequiresNT)); 
#else // !FEATURE_PAL 
        throw new NotImplementedException("ROTORTODO");
#endif // !FEATURE_PAL 
        PostInternal(callback);
    }

    // assert to disregard the user code up the compressed stack 
    [PermissionSet(SecurityAction.Assert, Unrestricted=true)]
    private static void CallCallbackWithAssert(WorkItemCallback callback) { 
        callback(); 
    }
 
    private static void OnQueueUserWorkItemCompletion(Object state) {
        WorkItemCallback callback = state as WorkItemCallback;

        if (callback != null) { 
            CallCallbackWithAssert(callback);
        } 
    } 

    internal static void PostInternal(WorkItemCallback callback) { 
        if (_useQueueUserWorkItem) {
            ThreadPool.QueueUserWorkItem(_onQueueUserWorkItemCompletion, callback);
        }
        else { 
            WrappedWorkItemCallback w = new WrappedWorkItemCallback(callback);
            w.Post(); 
        } 
    }
} 

internal class WrappedWorkItemCallback {
    private GCHandle         _rootedThis;
    private WorkItemCallback _originalCallback; 
    private WorkItemCallback _wrapperCallback;
 
    internal WrappedWorkItemCallback(WorkItemCallback callback) { 
        _originalCallback = callback;
        _wrapperCallback = new WorkItemCallback(this.OnCallback); 
    }

    internal void Post() {
        _rootedThis = GCHandle.Alloc(this); 

        if (UnsafeNativeMethods.PostThreadPoolWorkItem(_wrapperCallback) != 1) { 
            _rootedThis.Free(); 
            throw new HttpException(SR.GetString(SR.Cannot_post_workitem));
        } 
    }

    private void OnCallback() {
        _rootedThis.Free(); 
        _originalCallback();
    } 
} 

}

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK