ProcessThread.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Services / Monitoring / system / Diagnosticts / ProcessThread.cs / 1305376 / ProcessThread.cs
                        

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

namespace System.Diagnostics { 
 
    using System.Threading;
    using System.Runtime.InteropServices; 
    using System.ComponentModel;
    using System.Diagnostics;
    using System;
    using System.Collections; 
    using System.IO;
    using Microsoft.Win32; 
    using System.Security.Permissions; 
    using Microsoft.Win32.SafeHandles;
    using System.Runtime.Versioning; 
//    using System.Windows.Forms;

    /// 
    ///     
    ///       Represents a Win32 thread. This can be used to obtain
    ///       information about the thread, such as it's performance characteristics. This is 
    ///       returned from the System.Diagnostics.Process.ProcessThread property of the System.Diagnostics.Process component. 
    ///    
    ///     
    ///       I don't understand
    ///       the following comment associated with the previous sentence: "property of
    ///       Process component " Rather than just "processTHread". There is no such
    ///       member on Process. Do we mean 'threads'? 
    ///    
    ///  
    [ 
    Designer("System.Diagnostics.Design.ProcessThreadDesigner, " + AssemblyRef.SystemDesign),
    HostProtection(SelfAffectingProcessMgmt=true, SelfAffectingThreading=true) 
    ]
    public class ProcessThread : Component {

        // 
        // FIELDS
        // 
 
        ThreadInfo threadInfo;
        bool isRemoteMachine; 
        bool priorityBoostEnabled;
        bool havePriorityBoostEnabled;
        ThreadPriorityLevel priorityLevel;
        bool havePriorityLevel; 

        // 
        // CONSTRUCTORS 
        //
 
        /// 
        ///     Internal constructor.
        /// 
        ///  
        [ResourceExposure(ResourceScope.Process)]
        [ResourceConsumption(ResourceScope.Process)] 
        internal ProcessThread(bool isRemoteMachine, ThreadInfo threadInfo) { 
            this.isRemoteMachine = isRemoteMachine;
            this.threadInfo = threadInfo; 
            GC.SuppressFinalize(this);
        }

        // 
        // PROPERTIES
        // 
 
        /// 
        ///     Returns the base priority of the thread which is computed by combining the 
        ///     process priority class with the priority level of the associated thread.
        /// 
        [MonitoringDescription(SR.ThreadBasePriority)]
        public int BasePriority { 
            get {
                return threadInfo.basePriority; 
            } 
        }
 
        /// 
        ///     The current priority indicates the actual priority of the associated thread,
        ///     which may deviate from the base priority based on how the OS is currently
        ///     scheduling the thread. 
        /// 
        [MonitoringDescription(SR.ThreadCurrentPriority)] 
        public int CurrentPriority { 
            get {
                return threadInfo.currentPriority; 
            }
        }

        ///  
        ///     Returns the unique identifier for the associated thread.
        ///  
        [MonitoringDescription(SR.ThreadId)] 
        public int Id {
            [ResourceExposure(ResourceScope.Process)] 
            get {
                return threadInfo.threadId;
            }
        } 

        ///  
        ///     
        ///       Sets the processor that this thread would ideally like to run on.
        ///     
        /// 
        [Browsable(false)]
        public int IdealProcessor {
            [ResourceExposure(ResourceScope.Process)] 
            [ResourceConsumption(ResourceScope.Process)]
            set { 
                SafeThreadHandle threadHandle = null; 
                try {
                    threadHandle = OpenThreadHandle(NativeMethods.THREAD_SET_INFORMATION); 
                    if (NativeMethods.SetThreadIdealProcessor(threadHandle, value) < 0) {
                        throw new Win32Exception();
                    }
                } 
                finally {
                    CloseThreadHandle(threadHandle); 
                } 
            }
        } 

        /// 
        ///      Returns or sets whether this thread would like a priority boost if the user interacts
        ///      with user interface associated with this thread. 
        /// 
        [MonitoringDescription(SR.ThreadPriorityBoostEnabled)] 
        public bool PriorityBoostEnabled { 
            get {
                if (!havePriorityBoostEnabled) { 
                    SafeThreadHandle threadHandle = null;
                    try {
                        threadHandle = OpenThreadHandle(NativeMethods.THREAD_QUERY_INFORMATION);
                        bool disabled = false; 
                        if (!NativeMethods.GetThreadPriorityBoost(threadHandle, out disabled)) {
                            throw new Win32Exception(); 
                        } 
                        priorityBoostEnabled = !disabled;
                        havePriorityBoostEnabled = true; 
                    }
                    finally {
                        CloseThreadHandle(threadHandle);
                    } 
                }
                return priorityBoostEnabled; 
            } 
            set {
                SafeThreadHandle threadHandle = null; 
                try {
                    threadHandle = OpenThreadHandle(NativeMethods.THREAD_SET_INFORMATION);
                    if (!NativeMethods.SetThreadPriorityBoost(threadHandle, !value))
                        throw new Win32Exception(); 
                    priorityBoostEnabled = value;
                    havePriorityBoostEnabled = true; 
                } 
                finally {
                    CloseThreadHandle(threadHandle); 
                }
            }
        }
 
        /// 
        ///     Returns or sets the priority level of the associated thread.  The priority level is 
        ///     not an absolute level, but instead contributes to the actual thread priority by 
        ///     considering the priority class of the process.
        ///  
        [MonitoringDescription(SR.ThreadPriorityLevel)]
        public ThreadPriorityLevel PriorityLevel {
            get {
                if (!havePriorityLevel) { 
                    SafeThreadHandle threadHandle = null;
                    try { 
                        threadHandle = OpenThreadHandle(NativeMethods.THREAD_QUERY_INFORMATION); 
                        int value = NativeMethods.GetThreadPriority(threadHandle);
                        if (value == 0x7fffffff) { 
                            throw new Win32Exception();
                        }
                        priorityLevel = (ThreadPriorityLevel)value;
                        havePriorityLevel = true; 
                    }
                    finally { 
                        CloseThreadHandle(threadHandle); 
                    }
                } 
                return priorityLevel;
            }
            [ResourceExposure(ResourceScope.Process)]
            [ResourceConsumption(ResourceScope.Process)] 
            set {
                SafeThreadHandle threadHandle = null; 
                try { 
                    threadHandle = OpenThreadHandle(NativeMethods.THREAD_SET_INFORMATION);
                    if (!NativeMethods.SetThreadPriority(threadHandle, (int)value)) { 
                        throw new Win32Exception();
                    }
                    priorityLevel = value;
                } 
                finally {
                    CloseThreadHandle(threadHandle); 
                } 
            }
        } 

        /// 
        ///     Returns the amount of time the thread has spent running code inside the operating
        ///     system core. 
        /// 
        [MonitoringDescription(SR.ThreadPrivilegedProcessorTime)] 
        public TimeSpan PrivilegedProcessorTime { 
            get {
                EnsureState(State.IsNt); 
                return GetThreadTimes().PrivilegedProcessorTime;
            }
        }
 
        /// 
        ///     Returns the memory address of the function that was called when the associated 
        ///     thread was started. 
        /// 
        [MonitoringDescription(SR.ThreadStartAddress)] 
        public IntPtr StartAddress {
            get {
                EnsureState(State.IsNt);
                return threadInfo.startAddress; 
            }
        } 
 
        /// 
        ///     Returns the time the associated thread was started. 
        /// 
        [MonitoringDescription(SR.ThreadStartTime)]
        public DateTime StartTime {
            get { 
                EnsureState(State.IsNt);
                return GetThreadTimes().StartTime; 
            } 
        }
 
        /// 
        ///     Returns the current state of the associated thread, e.g. is it running, waiting, etc.
        /// 
        [MonitoringDescription(SR.ThreadThreadState)] 
        public ThreadState ThreadState {
            get { 
                EnsureState(State.IsNt); 
                return threadInfo.threadState;
            } 
        }

        /// 
        ///     Returns the amount of time the associated thread has spent utilizing the CPU. 
        ///     It is the sum of the System.Diagnostics.ProcessThread.UserProcessorTime and
        ///     System.Diagnostics.ProcessThread.PrivilegedProcessorTime. 
        ///  
        [MonitoringDescription(SR.ThreadTotalProcessorTime)]
        public TimeSpan TotalProcessorTime { 
            get {
                EnsureState(State.IsNt);
                return GetThreadTimes().TotalProcessorTime;
            } 
        }
 
        ///  
        ///     Returns the amount of time the associated thread has spent running code
        ///     inside the application (not the operating system core). 
        /// 
        [MonitoringDescription(SR.ThreadUserProcessorTime)]
        public TimeSpan UserProcessorTime {
            get { 
                EnsureState(State.IsNt);
                return GetThreadTimes().UserProcessorTime; 
            } 
        }
 
        /// 
        ///     Returns the reason the associated thread is waiting, if any.
        /// 
        [MonitoringDescription(SR.ThreadWaitReason)] 
        public ThreadWaitReason WaitReason {
            get { 
                EnsureState(State.IsNt); 
                if (threadInfo.threadState != ThreadState.Wait) {
                    throw new InvalidOperationException(SR.GetString(SR.WaitReasonUnavailable)); 
                }
                return threadInfo.threadWaitReason;
            }
        } 

        // 
        // METHODS 
        //
 
        /// 
        ///     Helper to close a thread handle.
        /// 
        ///  
        private static void CloseThreadHandle(SafeThreadHandle handle) {
            if (handle != null) { 
                handle.Close(); 
            }
        } 

        /// 
        ///     Helper to check preconditions for property access.
        ///  
        void EnsureState(State state) {
            if ( ((state & State.IsLocal) != (State)0) && isRemoteMachine) { 
                throw new NotSupportedException(SR.GetString(SR.NotSupportedRemoteThread)); 
            }
 
            if ((state & State.IsNt) != (State)0) {
                if (Environment.OSVersion.Platform != PlatformID.Win32NT) {
                    throw new PlatformNotSupportedException(SR.GetString(SR.WinNTRequired));
                } 
            }
        } 
 
        /// 
        ///     Helper to open a thread handle. 
        /// 
        /// 
        [ResourceExposure(ResourceScope.None)]  // Scoped by threadId
        [ResourceConsumption(ResourceScope.Process, ResourceScope.Process)] 
        SafeThreadHandle OpenThreadHandle(int access) {
            EnsureState(State.IsLocal); 
            return ProcessManager.OpenThread(threadInfo.threadId, access); 
        }
 
        /// 
        ///     Resets the ideal processor so there is no ideal processor for this thread (e.g.
        ///     any processor is ideal).
        ///  
        [ResourceExposure(ResourceScope.None)]
        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)] 
        public void ResetIdealProcessor() { 
            // 32 means "any processor is fine"
            IdealProcessor = 32; 
        }

        /// 
        ///     Sets which processors the associated thread is allowed to be scheduled to run on. 
        ///     Each processor is represented as a bit: bit 0 is processor one, bit 1 is processor
        ///     two, etc.  For example, the value 1 means run on processor one, 2 means run on 
        ///     processor two, 3 means run on processor one or two. 
        /// 
        [Browsable(false)] 
        public IntPtr ProcessorAffinity {
            [ResourceExposure(ResourceScope.Process)]
            [ResourceConsumption(ResourceScope.Process)]
            set { 
                SafeThreadHandle threadHandle = null;
                try { 
                    threadHandle = OpenThreadHandle(NativeMethods.THREAD_SET_INFORMATION | NativeMethods.THREAD_QUERY_INFORMATION); 
                    if (NativeMethods.SetThreadAffinityMask(threadHandle, new HandleRef(this, value)) == IntPtr.Zero) {
                        throw new Win32Exception(); 
                    }
                }
                finally {
                    CloseThreadHandle(threadHandle); 
                }
            } 
        } 

        private ProcessThreadTimes GetThreadTimes() { 
            ProcessThreadTimes threadTimes = new ProcessThreadTimes();

            SafeThreadHandle threadHandle = null;
            try { 
                threadHandle = OpenThreadHandle(NativeMethods.THREAD_QUERY_INFORMATION);
 
                if (!NativeMethods.GetThreadTimes(threadHandle, 
                    out threadTimes.create,
                    out threadTimes.exit, 
                    out threadTimes.kernel,
                    out threadTimes.user)) {
                    throw new Win32Exception();
                } 
            }
            finally { 
                CloseThreadHandle(threadHandle); 
            }
 
            return threadTimes;
        }

 
        /// 
        ///      Preconditions for accessing properties. 
        ///  
        /// 
        enum State { 
            IsLocal = 0x2,
            IsNt = 0x4
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

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