public EvoThreads(int threads, ThreadPriority priority) { // If the thread count is less than one or greater than the number of processors, throw an argument out of range exception if (threads < 1 || threads > Environment.ProcessorCount) throw new ArgumentOutOfRangeException("threads"); // Initialize the threads array this._threads = new Thread[threads]; // Initialize the event arrays this._resume = new AutoResetEvent[threads]; this._waiting = new ManualResetEvent[threads]; for (int i = 0; i < threads; i++) { // Create each thread in the threads array this._threads[i] = new Thread(new ParameterizedThreadStart(this.ThreadStart)); //Set Priority this._threads[i].Priority = priority; // Set the properties for each thread in the threads array this._threads[i].IsBackground = true; // Create each element in the event arrays this._resume[i] = new AutoResetEvent(false); this._waiting[i] = new ManualResetEvent(true); // Start each thread in the threads array this._threads[i].Start(i); } }
public BackgroundTaskQueueProvider(ThreadPriority priority) { // set up the task queue _queue = new List<string>(); // spin up the threads - two per logical CPU _maximumThreads = Environment.ProcessorCount * 2; #if DEBUG // if we're debugging, multithreading is a pain in the ass _maximumThreads = 1; #endif for (int i = 0; i < _maximumThreads; i++) { _threadStates.Add(i.ToString(), false); } for (int i = 0; i < _maximumThreads; i++) { Thread thread = new Thread(Processor) { Priority = priority, IsBackground = false, Name = i.ToString(CultureInfo.InvariantCulture) }; thread.Start(); _threadPool.Add(i.ToString(), thread); } }
public bool StartServer(string strEventName, string strPipeName, CMD_CALLBACK_PROC pfnCmdProc, object pParam, ThreadPriority iThreadPriority, int iCtrlCmdEventID) { if (pfnCmdProc == null || strEventName.Length == 0 || strPipeName.Length == 0) { return false; } if (m_ServerThread != null) { return false; } PipeServerThread RunThread = new PipeServerThread(m_hStopEvent); RunThread.m_pCmdProc = pfnCmdProc; RunThread.m_pParam = pParam; RunThread.m_strEventName = strEventName; RunThread.m_strPipeName = strPipeName; RunThread.m_iCtrlCmdEventID = iCtrlCmdEventID; CommonUtil._ResetEvent(m_hStopEvent); m_ServerThread = new Thread(new ThreadStart(RunThread.Run)); m_ServerThread.Priority = iThreadPriority; m_ServerThread.Start(); return true; }
public TaskSchedulerWithCustomPriority(int maxThreads, ThreadPriority threadPriority) { if (maxThreads < 1) throw new ArgumentOutOfRangeException("maxThreads"); this.maxThreads = maxThreads; _threadPriority = threadPriority; }
private ThumbnailSettings(Size size, InterpolationMode interpolationMode, Color backColor, ThreadPriority threadPriority) { this.size = size; this.interpolationMode = interpolationMode; this.backColor = backColor; this.threadPriority = threadPriority; }
public Work() { _state = WorkState.INIT; _description = string.Empty; _priority = ThreadPriority.Normal; _eventArgs = new WorkEventArgs(this); }
public ThreadWorker (IScheduler sched, ThreadWorker[] others, IProducerConsumerCollection<Task> sharedWorkQueue, bool createThread, int maxStackSize, ThreadPriority priority, EventWaitHandle handle) { this.others = others; this.dDeque = new CyclicDeque<Task> (); this.sharedWorkQueue = sharedWorkQueue; this.workerLength = others.Length; this.isLocal = !createThread; this.waitHandle = handle; this.childWorkAdder = delegate (Task t) { dDeque.PushBottom (t); sched.PulseAll (); }; // Find the stealing start index randomly (then the traversal // will be done in Round-Robin fashion) do { this.stealingStart = r.Next(0, workerLength); } while (others[stealingStart] == this); InitializeUnderlyingThread (maxStackSize, priority); }
/// <summary> /// Creates a new <c>SingleThreadExecutor</c> using a custom thread priority. /// </summary> /// <param name="priority"> /// The priority to assign the thread. /// </param> public SingleThreadExecutor(ThreadPriority priority) { _actions = new BlockingQueue<Action>(); _running = new AtomicBoolean(false); _shuttingDown = new AtomicBoolean(false); _priority = priority; }
public ThreadWorker (IScheduler sched, ThreadWorker[] others, IProducerConsumerCollection<Task> sharedWorkQueue, bool createThread, int maxStackSize, ThreadPriority priority) { this.others = others; // if (!string.IsNullOrEmpty (Environment.GetEnvironmentVariable ("USE_CYCLIC"))) { // Console.WriteLine ("Using cyclic deque"); // this.dDeque = new CyclicDeque<Task> (); // } else { // this.dDeque = new DynamicDeque<Task> (); // } this.dDeque = new CyclicDeque<Task> (); this.sharedWorkQueue = sharedWorkQueue; this.workerLength = others.Length; this.isLocal = !createThread; this.childWorkAdder = delegate (Task t) { dDeque.PushBottom (t); sched.PulseAll (); }; // Find the stealing start index randomly (then the traversal // will be done in Round-Robin fashion) do { this.stealingStart = r.Next(0, workerLength); } while (others[stealingStart] == this); InitializeUnderlyingThread (maxStackSize, priority); }
public SingleThreadTaskScheduler(string name = null, ThreadPriority priority = ThreadPriority.Normal, ApartmentState apartmentState = ApartmentState.STA) { #if DEBUG _allocStackTrace = new StackTrace(); #endif _thread = new Thread( () => { try { foreach (var task in _queue.GetConsumingEnumerable()) TryExecuteTask(task); } finally { _queue.Dispose(); } }); _thread.IsBackground = true; _thread.Name = name; _thread.Priority = priority; _thread.SetApartmentState(apartmentState); _thread.Start(); }
/// <summary> /// Замеряет и выводит на экран время потраченное на решение уравнений с использованием потоков /// </summary> /// <param name="totalEquationCount">Общее количество уравнений которые необходимо решить. Делится между потоками</param> /// <param name="threadCount">Кол-во потоков которые следует использовать для параллельного решения уравнений</param> /// <param name="priority">Приоритет потока</param> private static void BenchmarkWithThreads(int totalEquationCount, int threadCount, ThreadPriority priority = ThreadPriority.Normal) { if (totalEquationCount % threadCount != 0) throw new Exception(); Console.Write("Время на решение с потоками: "); int itemsPerThread = totalEquationCount / threadCount; // Кол-во уравнений для каждого потока Stopwatch watch = Stopwatch.StartNew(); Thread[] solveThreads = new Thread[threadCount]; for (int i = 0, offset = 0; i < solveThreads.Length; i++, offset += itemsPerThread) { solveThreads[i] = new Thread(SolveThread) { Name = String.Format("Решатель уравнений #{0}", i + 1), Priority = priority }; solveThreads[i].Start(itemsPerThread); } foreach (Thread solveThread in solveThreads) { solveThread.Join(); } watch.Stop(); Console.WriteLine("{0:F4} сек. Кол-во потоков: {1}. Приоритет: {2}", watch.Elapsed.TotalSeconds, threadCount, PriorityToString(priority)); }
public void ChangeThreadPriority(ThreadPriority priority) { if (_thread != null) { _thread.Priority = priority; } }
/// <summary> /// Class constructor initializes fields from config file /// </summary> static NUnitConfiguration() { try { NameValueCollection settings = GetConfigSection("NUnit/TestCaseBuilder"); if (settings != null) { string oldStyle = settings["OldStyleTestCases"]; if (oldStyle != null) allowOldStyleTests = Boolean.Parse(oldStyle); } settings = GetConfigSection("NUnit/TestRunner"); if (settings != null) { string apartment = settings["ApartmentState"]; if (apartment != null) apartmentState = (ApartmentState) System.Enum.Parse(typeof(ApartmentState), apartment, true); string priority = settings["ThreadPriority"]; if (priority != null) threadPriority = (ThreadPriority) System.Enum.Parse(typeof(ThreadPriority), priority, true); } } catch (Exception ex) { string msg = string.Format("Invalid configuration setting in {0}", AppDomain.CurrentDomain.SetupInformation.ConfigurationFile); throw new ApplicationException(msg, ex); } }
internal PipeServiceClientChannel(PipeServiceClient client, ThreadPriority listenThreadPriority, int receiveTimeout, int sendTimeout) { this.client = client; this.receiveTimeout = receiveTimeout; this.sendTimeout = sendTimeout; }
internal Thread(ThreadStart threadStart, ThreadPriority priority, SIP sip, TaskHandle task) { Task = task; _threadStart = threadStart; _priority = priority; _sip = sip; }
public ThreadPool(int initialThreadCount, int maxThreadCount, string poolName, int newThreadTrigger, int dynamicThreadDecayTime, ThreadPriority threadPriority, int requestQueueLimit) { SafeWaitHandle = _stopCompleteEvent.SafeWaitHandle; if (maxThreadCount < initialThreadCount) { throw new ArgumentException("Maximum thread count must be >= initial thread count.", "maxThreadCount"); } if (dynamicThreadDecayTime <= 0) { throw new ArgumentException("Dynamic thread decay time cannot be <= 0.", "dynamicThreadDecayTime"); } if (newThreadTrigger <= 0) { throw new ArgumentException("New thread trigger time cannot be <= 0.", "newThreadTrigger"); } ExceptionHelper.ThrowIfArgumentNullOrEmptyString(poolName, "poolName"); _initialThreadCount = initialThreadCount; _maxThreadCount = maxThreadCount; _requestQueueLimit = (requestQueueLimit < 0 ? DEFAULT_REQUEST_QUEUE_LIMIT : requestQueueLimit); _decayTime = dynamicThreadDecayTime; _newThreadTrigger = new TimeSpan(TimeSpan.TicksPerMillisecond * newThreadTrigger); _threadPriority = threadPriority; _requestQueue = new Queue<WorkRequest>(); _threadPoolName = poolName; }
protected WorkerThread(string name, ThreadPriority priority, ApartmentState apartmentState) { _thread = new Thread(new ThreadStart(this.InternalRun)); _thread.Name = name; _thread.Priority = priority; _thread.SetApartmentState(apartmentState); }
public ThreadBackground(ThreadBackgroundFlags flags) { this.flags = flags; this.currentThread = Thread.CurrentThread; this.oldThreadPriority = this.currentThread.Priority; if ((flags & ThreadBackgroundFlags.Cpu) == ThreadBackgroundFlags.Cpu && (activeFlags & ThreadBackgroundFlags.Cpu) != ThreadBackgroundFlags.Cpu) { this.currentThread.Priority = ThreadPriority.BelowNormal; activeFlags |= ThreadBackgroundFlags.Cpu; } if (Environment.OSVersion.Version >= OS.WindowsVista && (flags & ThreadBackgroundFlags.IO) == ThreadBackgroundFlags.IO && (activeFlags & ThreadBackgroundFlags.IO) != ThreadBackgroundFlags.IO) { IntPtr hThread = SafeNativeMethods.GetCurrentThread(); bool bResult = SafeNativeMethods.SetThreadPriority(hThread, NativeConstants.THREAD_MODE_BACKGROUND_BEGIN); if (!bResult) { NativeMethods.ThrowOnWin32Error("SetThreadPriority(THREAD_MODE_BACKGROUND_BEGIN) returned FALSE"); } } activeFlags |= flags; ++count; }
public void Repeat(string name, Action action, Action<Exception> onException, int interval = 100, ThreadPriority priority = ThreadPriority.Normal, CancellationToken? cancellationToken = null) { var thread = new Thread( () => { try { while (true) { if (cancellationToken.HasValue && cancellationToken.Value.IsCancellationRequested) break; Sleep(interval); action(); } } catch (Exception e) { onException(e); } } ); thread.Run(priority); Register(thread, cancellationToken, name); }
public static void SetThreadPriority(ThreadPriority priority) { if (Thread.CurrentThread.Priority != priority) { Thread.CurrentThread.Priority = priority; } }
public static Thread InBackground(Action action, ThreadPriority priority) { Thread thread = new Thread(() => action()); thread.Priority = priority; thread.IsBackground = true; thread.Start(); return thread; }
// Token: 0x06001841 RID: 6209 // RVA: 0x00074ED0 File Offset: 0x000730D0 public STPStartInfo() { this._performanceCounterInstanceName = SmartThreadPool.DefaultPerformanceCounterInstanceName; this._threadPriority = ThreadPriority.Normal; this._maxWorkerThreads = 25; this._idleTimeout = 60000; this._minWorkerThreads = 0; }
/// <summary> /// Constructor with a custom thread priority /// </summary> /// <param name="priority">The underlying thread's priority</param> public Actor(ThreadPriority priority) { m_messageQueue = new Queue<Message>(); m_waitHandle = new AutoResetEvent(false); m_thread = new Thread(MessagePump); m_thread.Priority = priority; m_thread.Start(); }
public STPStartInfo() { _performanceCounterInstanceName = SmartThreadPool.DefaultPerformanceCounterInstanceName; _threadPriority = SmartThreadPool.DefaultThreadPriority; _maxWorkerThreads = SmartThreadPool.DefaultMaxWorkerThreads; _idleTimeout = SmartThreadPool.DefaultIdleTimeout; _minWorkerThreads = SmartThreadPool.DefaultMinWorkerThreads; }
public STPStartInfo(STPStartInfo stpStartInfo) : base(stpStartInfo) { _idleTimeout = stpStartInfo.IdleTimeout; _minWorkerThreads = stpStartInfo.MinWorkerThreads; _maxWorkerThreads = stpStartInfo.MaxWorkerThreads; _threadPriority = stpStartInfo.ThreadPriority; _performanceCounterInstanceName = stpStartInfo.PerformanceCounterInstanceName; }
/// <summary> /// Creates a thread fiber. /// </summary> /// <param name="queue"></param> /// <param name="threadName"></param> /// <param name="isBackground"></param> /// <param name="priority"></param> public ThreadFiber(IQueue queue, string threadName, bool isBackground = true, ThreadPriority priority = ThreadPriority.Normal) { _queue = queue; _thread = new Thread(RunThread); _thread.Name = threadName; _thread.IsBackground = isBackground; _thread.Priority = priority; _scheduler = new Scheduler(this); }
/// <summary> /// Creates a new instance of the <see cref="WorkItem"/> class. /// </summary> protected WorkItem() { createdTime = DateTime.Now; priority = ThreadPriority.Normal; state = WorkItemState.Created; // Capture the invokers context. uiCulture = Thread.CurrentThread.CurrentUICulture; }
public STPStartInfo(STPStartInfo stpStartInfo) : base(stpStartInfo) { _idleTimeout = stpStartInfo._idleTimeout; _minWorkerThreads = stpStartInfo._minWorkerThreads; _maxWorkerThreads = stpStartInfo._maxWorkerThreads; _threadPriority = stpStartInfo._threadPriority; _pcInstanceName = stpStartInfo._pcInstanceName; }
public Scheduler (int maxWorker, int maxStackSize, ThreadPriority priority) { workQueue = new ConcurrentQueue<Task> (); workers = new ThreadWorker [maxWorker]; for (int i = 0; i < maxWorker; i++) { workers [i] = new ThreadWorker (this, workers, workQueue, maxStackSize, priority); } }
public AudioPipe(IAudioSource source, int size, bool own, ThreadPriority priority) : this(source.PCM, size) { this.own = own; this.priority = priority; _source = source; _sampleLen = _source.Length; _samplePos = _source.Position; }
public static IDisposable SubscribeToLatestOnBGThread(this IObservable <Action> subject , Action <Exception> onError, ThreadPriority priority = ThreadPriority.Normal) { return(subject.SubscribeToLatestOnBGThread(a => a(), onError, priority)); }
/// <summary> /// Set Priority of the thread /// </summary> /// <param name="priority">The priority of the thread</param> /// <returns>true if successfully set otherwise false</returns> public bool SetPriority(ThreadPriority priority) { m_threadPriority = priority; m_threadHandle.Priority = priority; return(true); }
internal void init(IceInternal.Instance instance, ThreadPriority priority, bool hasPriority)
protected WorkerThreadBase(string name, ThreadPriority priority) : this(name, priority, false) { }
/// <summary> /// Sets a value indicating the scheduling priority of a thread. /// </summary> /// <param name="newPriority">One of the <see cref="System.Threading.ThreadPriority"/> values.</param> public void SetPriority(ThreadPriority newPriority) { ProcessAPI.CeSetThreadPriority((uint)this.ThreadID, (int)newPriority); }
/// <summary> /// Create a new <see cref="SimpleThreadPool" /> with the specified number /// of <see cref="Thread" /> s that have the given priority. /// </summary> /// <param name="threadCount"> /// the number of worker <see cref="Thread" />s in the pool, must /// be > 0. /// </param> /// <param name="threadPriority"> /// the thread priority for the worker threads. /// /// </param> public SimpleThreadPool(int threadCount, ThreadPriority threadPriority) { ThreadCount = threadCount; ThreadPriority = threadPriority; }
static extern bool SetThreadPriority(IntPtr hThread, ThreadPriority nPriority);
public const int DefaultThreadPoolSize = -1; // Use the operating system default value public CustomThreadPool(string name, int threadPoolSize = DefaultThreadPoolSize, ThreadPriority priority = ThreadPriority.Normal) { if (threadPoolSize == DefaultThreadPoolSize) { int n; ThreadPool.GetMaxThreads(out _threadPoolSize, out n); } else { Debug.Assert(threadPoolSize > 0); _threadPoolSize = threadPoolSize; } _threads = new List <CustomThreadPoolThread>(); _semaphore = new Semaphore(_threadPoolSize, _threadPoolSize); Priority = priority; Name = name; }
/// <summary> /// 更改指定线程的优先级。 /// </summary> /// <param name="thread">指定的线程实例。</param> /// <param name="priority">需要设置的线程优先级。</param> public static void ChangeThreadPriority(Thread thread, ThreadPriority priority) => thread.Priority = priority;
public PriorityScheduler(ThreadPriority priority) { _priority = priority; }
public static DataLoader CreateDataLoader(string ConnectionStringName, DataFileInfo flFileInfo, int ThreadCount, ThreadPriority threadPriority, int CommitAfter) { ConnectionStringSettings settings = ConfigurationManager.ConnectionStrings[ConnectionStringName]; switch (settings.ProviderName.ToUpper()) { case "ORACLE": return(OracleDataLoader.CreateDataLoader(settings.ConnectionString, flFileInfo, ThreadCount, threadPriority, CommitAfter)); case "SQLSERVER": return(SqlServerDataLoader.CreateDataLoader(settings.ConnectionString, flFileInfo, ThreadCount, threadPriority)); } return(null); }
private bool SetPriorityLive(ThreadPriority priority) { Debug.Assert(!_osHandle.IsInvalid); return(Interop.Kernel32.SetThreadPriority(_osHandle, (int)MapToOSPriority(priority))); }
/// <summary> /// Start a new thread that is tracked by the watchdog timer. /// </summary> /// <param name="start">The method that will be executed in a new thread</param> /// <param name="name">A name to give to the new thread</param> /// <param name="priority">Priority to run the thread at</param> /// <param name="isBackground">True to run this thread as a background thread, otherwise false</param> /// <param name="alarmIfTimeout">Trigger an alarm function is we have timed out</param> /// <param name="log">If true then creation of thread is logged.</param> /// <returns>The newly created Thread object</returns> public static Thread StartThread( ThreadStart start, string name, ThreadPriority priority, bool isBackground, bool alarmIfTimeout, bool log = true) { return(StartThread(start, name, priority, isBackground, alarmIfTimeout, null, DEFAULT_WATCHDOG_TIMEOUT_MS, log)); }
private IEnumerator InternalDownloadAssets(AssetDownloader.DownloadState state, bool checkUpdates, bool isRetry, ThreadPriority threadPriority) { // ISSUE: object of a compiler-generated type is created return((IEnumerator) new AssetDownloader.\u003CInternalDownloadAssets\u003Ec__Iterator44() { checkUpdates = checkUpdates, isRetry = isRetry, threadPriority = threadPriority, state = state, \u003C\u0024\u003EcheckUpdates = checkUpdates, \u003C\u0024\u003EisRetry = isRetry, \u003C\u0024\u003EthreadPriority = threadPriority, \u003C\u0024\u003Estate = state, \u003C\u003Ef__this = this }); }
//Sets the priority of the threads public void SetPriority(ThreadPriority _priority) { this.backgroundWorker.Priority = _priority; }
public static AssetDownloader.DownloadState StartTextDownload(bool checkUpdates, bool canRetry = true, ThreadPriority threadPriority = ThreadPriority.Normal) { if (AssetDownloader.mCoroutine != null || !checkUpdates && AssetDownloader.mRequestIDs.Count == 0 || AssetDownloader.mDownloadedText) { return((AssetDownloader.DownloadState)null); } if (AssetManager.Format != AssetManager.AssetFormats.Text) { AssetDownloader.mCachePath = AssetDownloader.mTextCachePath; AssetManager.Format = AssetManager.AssetFormats.Text; } AssetDownloader.DownloadState state = new AssetDownloader.DownloadState(); AssetDownloader.mRetryOnError = canRetry; AssetDownloader.mCoroutine = AssetDownloader.Instance.StartCoroutine(AssetDownloader.Instance.InternalDownloadAssets(state, checkUpdates, false, threadPriority)); return(state); }
public WorkerQueue(ThreadPriority priority = ThreadPriority.Normal) { _priority = priority; }
public FuncLooper(string id, ThreadPriority priority, int interval, Func <T> repeat) : base(id, priority, interval) { _repeat = repeat; }
// // Only for use by Instance. // #if !SILVERLIGHT internal Timer(IceInternal.Instance instance, ThreadPriority priority) { init(instance, priority, true); }
public void WriteTo(FlushOutput flushOutputDelegate, CloseOutput closeOutputDelegate, ThreadPriority priority, object to) { if (flushOutputDelegate != null) { flushOutput += flushOutputDelegate; } if (closeOutputDelegate != null) { closeOutput += closeOutputDelegate; } _writeThread = new Thread(FlushThread); _writeThread.Priority = priority; _writeThread.IsBackground = true; _writeThread.Start(to); }
/// <summary> /// 循环间隔运行 /// </summary> /// <param name="doWork"></param> /// <param name="interval"></param> /// <param name="stopped"></param> /// <param name="isBackground"></param> /// <param name="priority"></param> /// <returns></returns> public static Thread PulseAction(Action doWork, TimeSpan interval, bool stopped = false, bool isBackground = true, ThreadPriority priority = ThreadPriority.Highest) { var td = Run(() => { while (!stopped) { doWork.Invoke(); Sleep((int)interval.TotalMilliseconds); } }, isBackground, priority); return(td); }
public IWork Add(DoWorkHandler work, ThreadPriority threadPriority) { IWork w = new Work(work, threadPriority); return(Add(w) ? w : null); }
public IWork Add(DoWorkHandler work, string description, QueuePriority queuePriority, ThreadPriority threadPriority, WorkEventHandler workCompletedHandler) { IWork w = new Work(work, description, threadPriority, workCompletedHandler); return(Add(w, queuePriority) ? w : null); }
public static IDisposable SubscribeToLatestOnBGThread <TSource>(this IObservable <TSource> subject , Action <TSource> onNext, Action <Exception> onError, ThreadPriority priority = ThreadPriority.Normal) { return(subject.SubscribeToLatestOnBGThread(onNext, onError, () => { }, priority)); }
public static DataLoader CreateDataLoader(DbTypes DatabaseType, string ConnectionString, DataFileInfo flFileInfo, int ThreadCount, ThreadPriority threadPriority, int CommitAfter) { switch (DatabaseType) { case DbTypes.Oracle: return(OracleDataLoader.CreateDataLoader(ConnectionString, flFileInfo, ThreadCount, threadPriority, CommitAfter)); case DbTypes.SqlServer: return(SqlServerDataLoader.CreateDataLoader(ConnectionString, flFileInfo, ThreadCount, threadPriority)); } return(null); }
public static IDisposable SubscribeToLatestOnBGThread <TSource>(this IObservable <TSource> subject , Action <TSource> onNext, Action <Exception> onError, Action onCompleted, ThreadPriority priority = ThreadPriority.Normal) { return(subject.Latest() .ToObservable(BGTreadSchedulerFactory(priority)) .Subscribe(onNext, onError, onCompleted)); }
public IWorkItemResult QueueWorkItem <T>(Action <T> action, T item, bool background = true, ThreadPriority priority = ThreadPriority.Normal, WorkItemPriority itemPriority = WorkItemPriority.Normal) { var pool = getPool(background, priority, itemPriority); return(pool.QueueWorkItem(action, item, itemPriority)); }
private static bool SetPriority(ThreadPriority priority) { return(true); }
public void RegisterHeldOffTask(DoMaintenanceDelegate do_maintenance_delegate, int delay_before_start_milliseconds, ThreadPriority thread_priority, int hold_off_level = 0, string extra_descr = "") { Utilities.LockPerfTimer l1_clk = Utilities.LockPerfChecker.Start(); lock (do_maintenance_delegate_wrappers_lock) { l1_clk.LockPerfTimerStop(); // Set up the wrapper DoMaintenanceDelegateWrapper do_maintenance_delegate_wrapper = new DoMaintenanceDelegateWrapper(); do_maintenance_delegate_wrapper.maintainable_description = String.Format("{0}:{1}{2}", do_maintenance_delegate.Target, do_maintenance_delegate.Method.Name, extra_descr); do_maintenance_delegate_wrapper.target = new WeakReference(do_maintenance_delegate.Target); do_maintenance_delegate_wrapper.method_info = do_maintenance_delegate.Method; do_maintenance_delegate_wrapper.delay_before_start_milliseconds = delay_before_start_milliseconds; do_maintenance_delegate_wrapper.hold_off_level = hold_off_level; do_maintenance_delegate_wrapper.daemon = new Daemon("Maintainable:" + do_maintenance_delegate.Target.GetType().Name + "." + do_maintenance_delegate.Method.Name + extra_descr); // Add it to our list of trackers do_maintenance_delegate_wrappers.Add(do_maintenance_delegate_wrapper); // Start the thread do_maintenance_delegate_wrapper.daemon.Start(DaemonThreadEntryPoint, do_maintenance_delegate_wrapper); do_maintenance_delegate_wrapper.daemon.Priority = thread_priority; } }
public void In( [FriendlyName("levelCount", "The total number of levels available.")] [SocketState(false, false)] out int levelCount, [FriendlyName("loadedLevel", "The level index that was last loaded.")] [SocketState(false, false)] out int[] loadedLevels, [FriendlyName("loadedLevelName", "The name of the level that was last loaded.")] [SocketState(false, false)] out string[] loadedLevelNames, [FriendlyName("isEditor", "Are we running inside the Unity editor?")] [SocketState(false, false)] out bool isEditor, [FriendlyName("isPlaying", "Returns true when in any kind of player.")] [SocketState(false, false)] out bool isPlaying, #if !(UNITY_2017_2_OR_NEWER) [FriendlyName("isWebPlayer", "Are we running inside a web player?")] [SocketState(false, false)] out bool isWebPlayer, #endif [FriendlyName("streamedBytes", "Returns the number of bytes that have been downloaded from the main unity web stream.")] [SocketState(false, false)] out int streamedBytes, [FriendlyName("platform", "Returns the platform the game is running (Read Only).")] [SocketState(false, false)] out RuntimePlatform platform, [FriendlyName("dataPath", "Contains the path to the game data folder (Read Only).")] [SocketState(false, false)] out string dataPath, [FriendlyName("persistentDataPath", "Contains the path to a persistent data directory (Read Only).")] [SocketState(false, false)] out string persistentDataPath, [FriendlyName("temporaryCachePath", "Contains the path to a temporary data / cache directory (Read Only).")] [SocketState(false, false)] out string temporaryCachePath, #if !(UNITY_2017_2_OR_NEWER) [FriendlyName("srcValue", "The path to the web player data file relative to the html file (Read Only).")] [SocketState(false, false)] out string srcValue, #endif [FriendlyName("absoluteURL", "The absolute path to the web player data file (Read Only).")] [SocketState(false, false)] out string absoluteURL, [FriendlyName("systemLanguage", "The language the user's operating system is running in.")] [SocketState(false, false)] out SystemLanguage systemLanguage, [FriendlyName("internetReachability", "Returns internet reachability status.")] [SocketState(false, false)] out NetworkReachability internetReachability, [FriendlyName("webSecurityEnabled", "Indicates whether Unity's webplayer security model is enabled.")] [SocketState(false, false)] out bool webSecurityEnabled, [FriendlyName("webSecurityHostUrl", "[This appears to be undocumented!]")] [SocketState(false, false)] out string webSecurityHostUrl, [FriendlyName("runInBackground", "Returns the application background play state.")] [SocketState(false, false)] out bool runInBackground, [FriendlyName("targetFrameRate", "Returns the frame rate the game is instructed to use. The value is the ideal frame rate and may not reflect the actual frame rate.")] [SocketState(false, false)] out int targetFrameRate, [FriendlyName("backgroundLoadingPriority", "Returns the priority of background loading thread.")] [SocketState(false, false)] out ThreadPriority backgroundLoadingPriority, [FriendlyName("unityVersion", "The version of the Unity runtime used to play the content.")] out string unityVersion ) { levelCount = UnityEngine.SceneManagement.SceneManager.sceneCountInBuildSettings; #if UNITY_5_3_0 UnityEngine.SceneManagement.Scene[] scenes = UnityEngine.SceneManagement.SceneManager.GetAllScenes(); loadedLevels = new int[scenes.Length]; loadedLevelNames = new string[scenes.Length]; for (int i = 0; i < scenes.Length; i++) { loadedLevels[i] = scenes[i].buildIndex; loadedLevelNames[i] = scenes[i].name; } #else loadedLevels = new int[UnityEngine.SceneManagement.SceneManager.sceneCount]; loadedLevelNames = new string[UnityEngine.SceneManagement.SceneManager.sceneCount]; for (int i = 0; i < UnityEngine.SceneManagement.SceneManager.sceneCount; i++) { UnityEngine.SceneManagement.Scene scene = UnityEngine.SceneManagement.SceneManager.GetSceneAt(i); loadedLevels[i] = scene.buildIndex; loadedLevelNames[i] = scene.name; } #endif isEditor = Application.isEditor; isPlaying = Application.isPlaying; #if !(UNITY_2017_2_OR_NEWER) isWebPlayer = Application.isWebPlayer; #endif streamedBytes = Application.streamedBytes; platform = Application.platform; dataPath = Application.dataPath; persistentDataPath = Application.persistentDataPath; temporaryCachePath = Application.temporaryCachePath; #if !(UNITY_2017_2_OR_NEWER) srcValue = Application.srcValue; #endif absoluteURL = Application.absoluteURL; unityVersion = Application.unityVersion; systemLanguage = Application.systemLanguage; internetReachability = Application.internetReachability; #if !(UNITY_5_5_OR_NEWER || UNITY_2017 || UNITY_2018) webSecurityEnabled = Application.webSecurityEnabled; webSecurityHostUrl = Application.webSecurityHostUrl; #else webSecurityEnabled = false; webSecurityHostUrl = ""; #endif backgroundLoadingPriority = Application.backgroundLoadingPriority; runInBackground = Application.runInBackground; targetFrameRate = Application.targetFrameRate; }