CThreadManager.CreateThreadMgr(0);

NWDistThreadWorkItem dtwi = new NWDistThreadWorkItem("DistThread", _
  Config.IsThreadTraceItemSet(NWConfigInfo.ThreadTraceItems.DistThread));
CThreadManager.ThreadMgr.StartSystemThread(dtwi, true, false);

static Thread mythread = new Thread(...);

using System;
using System.Collections;
using System.ComponentModel;
using System.Web;
using System.Web.SessionState;
using System.Diagnostics;
 
namespace XXApp
{
	/// <summary>
	/// Global.asax for XXApp application
	/// </summary>
	public class Global : System.Web.HttpApplication
	{
		protected XXApplication _app = XXApplication.NWApp;
 
		protected void Application_Start(Object sender, EventArgs e)
		{
			_app.InitApplication(this.Context);
		}
 
		protected void Application_BeginRequest(Object sender, EventArgs e)
		{
			_app.BeginRequest(this.Context);
		}
 
		protected void Application_EndRequest(Object sender, EventArgs e)
		{
			_app.EndRequest(this.Context);
		}
 
		protected void Application_End(Object sender, EventArgs e)
		{
			_app.TermApplication(this.Context);
		}
	}
}

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
using System.Text;
using System.IO;
using System.Diagnostics;
using System.Xml;
using System.Web.Caching;
using System.Threading;
using System.Security.Cryptography;
using System.Globalization;
using Microsoft.Win32;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
 
using NWConfig;
using NWCommon;
using NWXmit;
 
namespace XXApp
{
	/// <summary>
	/// This class contains various methods and variables for errors,
	/// common service functions etc. which apply to the whole application
	/// This is really an extension to Global.asax but keeps the code out of
	/// the internally viewable Global.asax class
	///
	///It also performs startup initialisation and termination
	/// for the XXApp webb application.
	/// The InitApplication() routine is called from Global.asax Application_Start( _
  )
	/// The TermApplication() routine is called from Global.asax Application_End()
	/// The BegingRequest() routine is called from Global.asax _
  Application_BeginRequest()
	/// The EndRequest() routine is called from Global.asax Application_EndRequest( _
)
 
	/// DS04012
	/// Implement thread wait timing service
	/// 
	/// DS04013 
	/// NWTraceHandler
 
	/// </summary>
 
	public sealed class XXApplication
	{
		// Global test variables to prevent certain things happening
		private const bool _noSubTasks = false;
		private const bool _noRestart = false;
		private const bool _noAgeCheck = false;
 
		// This is the global application singleton code
		private static XXApplication __app = new XXApplication();
		public static XXApplication NWApp {get{ return __app;}}
 
		// Allow only a single instance of XXApplication
		private XXApplication() {_startupTime = DateTime.Now;}
 
		// Startup stuff
		private DateTime _startupTime;
		private Mutex _appSynchMutex = null;
		internal Mutex AppSynchMutex{get{return _appSynchMutex;}}
		private bool _holdAppSynchMutex = false;
		private Mutex _appSynchMutex1 = null;
		internal Mutex AppSynchMutex1{get{return _appSynchMutex1;}}
		private bool _holdAppSynchMutex1 = false;
 
		// DS04013
		private bool _cacheTrace = true;
		internal bool CacheTrace {get{return _cacheTrace;}}
		private bool _startupOK = true;
		internal bool StartupOK {get{return _startupOK;}}
		internal ArrayList _traceCache = new ArrayList();
		internal ArrayList TraceCache {get{return _traceCache;}}
 
		// Some globally available items
		// (We like this better than stuff in ApplicationStatus with expensive _
  Dictionary lookup...)
		private System.Web.HttpApplicationState _application = null; // Our web app
		internal System.Web.HttpApplicationState AspApp { get{return _application;} }
 
		private System.Web.Caching.Cache _appCache = null; // The application cache
		internal System.Web.Caching.Cache AppCache { get{return _appCache;} }
 
		private System.Web.HttpServerUtility _server = null; // Our web server object
		internal System.Web.HttpServerUtility AspServer { get{return _server;} }
 
		// Note: this variable is set here during application init, and is otherwise _
  always 
		// referenced via the Config property procedure.
		// The Config property is used by all other XXApp code to access the _
  configuration data
		// (Not that that matters any more since we changed the Config Update code...)
		private CServerConfigInfo _config = null; // The current NWConfigInfo object
		internal CServerConfigInfo Config
		{
			get{return _config;}
			set{_config = value;}
		} // Property Config
 
		// Registry values
		private bool _registryKeyFound = false;
		private string _product_Version = NWConsts.Registry_Product_Version;
		private string _appSynchMutexName = NWConsts.App_Synch_Mutex_Name;
		internal string AppSynchMutexName {get{return _appSynchMutexName;}}
		private string _regConfigPath = ""; 
		private int _utel = 0; // Use TextLog
		private int _configRestartDelay = -1; // Config Restart Delay
		private int _telog = 0; // Trace event log thread
		private int _ttlog = 0; // Trace trace log thread
		private int _showXml = 0; // Show XML in trace, test option only!
		private int _autorestartServer = 0; // Test option only!
		internal int AutorestartServer{get{return _autorestartServer;}}
		private int _threadHangTest = 0; // Make request sleep
		internal bool ThreadHangTest{get{return _threadHangTest==1;}} 
 
			// Config path for Admin config update
			private string _configFilePath = "";
		internal string ConfigFilePath{get{return _configFilePath;}}
 
		// Config path for temp save of config values over restart
		private string _configSaveFilePath = "";
 
		// Server Id MD5 hash created from Config.ServerId
		// (Note: in ConfigInfo for restart save)
		internal byte[] ServerIdHash{get{return Config.ServerIdHash;}}
 
		// Hashtable for failed logon attempts 
		// (Note: in ConfigInfo for restart save)
		internal System.Collections.Hashtable LogonAttemptItems{get{return _
  Config.Lais;}}
		internal int FailedLogonCacheCount{get{return _
Config.Lais==null?0:Config.Lais.Count;}}
 
		// Hashtable for active user objects
		// (Note: this is rebuilt dynamically and not saved over restart))
		private System.Collections.Hashtable _nwusersCache = null; // Current _
  'collection' of active users 
		internal System.Collections.Hashtable UsersCache{get{return _nwusersCache;}}
		internal int UserObjectCacheCount{get{return _
  _nwusersCache==null?0:_nwusersCache.Count;}}
 
		// The global XmlManager copied by processing threads
		// (Note: this is rebuilt dynamically and not saved over restart))
		private CServerXMLRRManager _xmlMgr = null; // Global XMLRRManager for _
  definitions
		internal CServerXMLRRManager XmlMgr {get{return _xmlMgr;}}
 
		// Log and Trace stuff
		private CEventLog _eventLog = null;
		private bool _eventLogReady = false;
		private CTextLog _eventTLog = null;
		private CTextLog _traceTLog = null;
		private NWTrace _trace = null;
		private CultureInfo _ci = null;
		internal CultureInfo Culture{get{return _ci;}} // Property Culture
 
		// Config manager data (NWAdminRequestHandler)
		internal DateTime LastConfigUpdateTime
		{
			get{return Config.LastConfigUpdateTime;}
			set{Config.LastConfigUpdateTime = value;}
		} // Property LastConfigUpdateTime
 
		// Cleanup thread values
		private DateTime _lastCleanupTime = DateTime.MinValue;
		internal DateTime LastCleanupTime
		{
			get{return _lastCleanupTime;}
			set{_lastCleanupTime = value;}
		} // Property LastCleanupTime
 
		// Global flag if init failed
		private bool _errorNoInit = false;
 
		// Global flag if config member load failed
		private bool _loadError = false;				
		internal bool LoadError
		{ 
			get{return _loadError;}
			set{_loadError = value;}
		}
 
		// Global application closedown flag
		private bool _closeDown = false;
		internal bool CloseDown {get{return _closeDown;}}
 
		// Closedown sessions active temporaries for saving session status
		private ArrayList _closeDownSessions = null;
		private DateTime _saveStartTime;
		internal DateTime SaveStartTime{get{return _saveStartTime;}} // Property _
  SaveStartTime
		private bool _restart = false;
 
		// Perform one-time initialisation for the XXApp Web Application
		// This is the main startup code for the application called from
		// global.asax.InitApplication()
		public void InitApplication(System.Web.HttpContext context)
		{
			try
			{	
				// Set up global statics
				_application = context.Application;
				_appCache = context.Cache;
				_server = context.Server;
 
				// Set culture info for this server
				_ci = Thread.CurrentThread.CurrentCulture;
 
				// Read special registry keys
				readRegistry();
 
				// Perform trace init
				initTrace(context);
 
				// Write app started to init the event log
				// (Note: event log only really started after config data read)
				initLog();
 
				// Create the global thread manager
				CThreadManager.CreateThreadMgr(0);
 
				// Create the global lock manager
				CLockManager.CreateLockMgr();
 
				// Create the global distribution manager
				NWDist.CreateDistMgr();		
 
				// Load config data
 
				// Wait (maybe) until a previous incarnation has passed away...
				_appSynchMutex = GetMutex(_appSynchMutex, _appSynchMutexName, 10000, ref _
  _holdAppSynchMutex);
				_appSynchMutex1 = GetMutex(_appSynchMutex1, _appSynchMutexName+"1", 10000, _
ref _holdAppSynchMutex1);
 
				// Set NWConfig filepath
				// Directory containing the NWConfig member
				string path = _regConfigPath;
				if (path==null||path=="")
					path = AppDomain.CurrentDomain.BaseDirectory;
				_configFilePath = path+NWConsts.config_member_name;
				_configSaveFilePath = _configFilePath+NWConsts.config_save_file_extension; 
 
				// Start load timing
				DateTime cflst = DateTime.Now;
 
				// First see if saved config (if any) is still valid
				if (_configRestartDelay!=0)
				{
					_config = (CServerConfigInfo)restoreObject(_configSaveFilePath, ( _
  _configRestartDelay==-1)?15:_configRestartDelay, false);
					_restart = _config!=null;
				}
 
				// If not reloaded after restart, get the global config data
				if (!_restart)
				{
					_config = GetGlobalConfig();
				}
 
				// Init tracing and trace and event logs
				InitLogs(_config);
 
				// If not reloaded after restart, get other config data
				if (!_restart)
				{
					// Get the config items (Users, Groups, Profiles, Variables)
					GetConfigItems(_config);
 
					// Get the server hash value if required
					if (_config.ServerId!="")
					{
						MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
						_config.ServerIdHash = md5.ComputeHash(CUtil.StringToByte( _
  _config.ServerId));
						md5.Clear();
					}
 
					// Set config accessability for other components
					_config.LastConfigUpdateTime = DateTime.Now;				
 
					// Create the logon attempts hashtable
					_config.Lais = new System.Collections.Hashtable();
 
					// Now save the newla read config data for possible restart
					if ((_configRestartDelay!=0))
					{
						bool configSaved = SaveConfigData( _config);
						if (!configSaved)
							WriteLog("Application Init unable to save loaded config data", _
  NWConsts.event_error, NWConsts.Event_Id_App_Init, 0);
					}
				} // if(!_restart)
 
				// Show load time
				if (CTrace.TraceOn) CTrace.Trace1("Config load time: "+( _
  DateTime.Now-cflst).TotalMilliseconds.ToString()+" (millisecs)", "SrvrApp");
 
				// Create the global XMLRRManager
				_xmlMgr = new CServerXMLRRManager(_showXml==1);
 
				// Create the user object hash table
				_nwusersCache = new System.Collections.Hashtable();
 
				// DS04012
				// Create the thread timer
				NWTT.CreateNWTT(Config.MaxThreadDelay>0);
 
				// Start the various system service subtasks
				if (!_noSubTasks) // Test constant - see top of code
				{
					// Record partially distributed files and
					// create the partial distribution workers
					NWProcessPartialDistributionFilesWorkItem ppdfwi = new _
  NWProcessPartialDistributionFilesWorkItem(Config.IsThreadTraceItemSet( _
  NWConfigInfo.ThreadTraceItems.ProcessPartialDistFiles));
					if (Config.MultiThreadStartup)
						CThreadManager.ThreadMgr.StartSystemThread(ppdfwi, true, false);
					else
						ppdfwi.DoWork();
 
					// Create the permanent delete worker for partially uploaded files
					NWDist.DistMgr.CreateUploadDeleteWorker();
 
					// Create the permanent delete worker for completely downloaded files
					NWDist.DistMgr.CreateDeleteWorker();
 
					// Maybe start the permanent distribution worker
					if (( _
  Config.DistThreading&NWConfigInfo.DistributionThreadingType.SystemThread)==NW_
  ConfigInfo.DistributionThreadingType.SystemThread)
					{
						NWDistThreadWorkItem dtwi = new NWDistThreadWorkItem("DistThread", _
  Config.IsThreadTraceItemSet(NWConfigInfo.ThreadTraceItems.DistThread));
						CThreadManager.ThreadMgr.StartSystemThread(dtwi, true, false); 
					}
 
					// Start the permanent services worker
					NWServicesWorkItem swi = new NWServicesWorkItem("Services", _
  Config.ServicesWorkerInterval, Config.IsThreadTraceItemSet( _
  NWConfigInfo.ThreadTraceItems.Services));
					CThreadManager.ThreadMgr.StartSystemThread(swi, true, false); 
 
					// Test!
					//CThreadManager.ThreadMgr.ListActiveThreads();
 
				} // if (_noSubTasks)
 
				// Now attempt to restart any sessions which were running at closedown
				if ((!_noRestart)&&(_configRestartDelay!=0)) // Test constant - see top of _
  code
					restartSessions();
 
				// Startup was completed successfully
				WriteLog("Application Init completed at: "+DateTime.Now.ToLongTimeString( _
  )+" startup time: "+(DateTime.Now-_startupTime).TotalMilliseconds.ToString( _
  )+" (millisecs)", NWConsts.event_warning, NWConsts.Event_Id_App_Init, 0);
			}
			catch(System.Exception ex)
			{
				_errorNoInit = true;
				if (_config!=null) initEventLog(_config);
				ThreadError(ex, "XXApplication", "InitApplication", "Error in" & _
  "InitApplication: "+ex.Message);
			}
			finally
			{
				// Free the app synchronisation mutexes (Services Thread now holds
				// _appSynchMutex)
				FreeMutex(_appSynchMutex, _appSynchMutexName, ref _holdAppSynchMutex); 
				FreeMutex(_appSynchMutex1, _appSynchMutexName+"1", ref _holdAppSynchMutex1); 
 
				// DS04013
				_cacheTrace = false;
				_startupOK = !_errorNoInit;
				if (_startupOK)
					_traceCache = null;
			}
 
		} // InitApplication
 
		// Perform termination for the XXApp Web Application
		// This is the main termination code for the application called from
		// global.asax.TermApplication()
		public void TermApplication(System.Web.HttpContext context)
		{
			try
			{
				// Init thread trace
				CTrace.InitThreadTrace("AppTerm");
 
				// Always init Init ASP page trace for application termination
				// So context is null in IIS 5, we can't do ASP tracing after all...
				//if (context!=null) CTrace.SetPageTrace(context.Trace);
 
				// Write shutdown message
				WriteLog("Application Termination started at:" & _
  ""+DateTime.Now.ToLongTimeString(), NWConsts.event_warning, _
  NWConsts.Event_Id_App_Term, 0);
				_closeDown = true;
 
				// Obtain the second mutex for application synchronisation
				_appSynchMutex1 = GetMutex(_appSynchMutex1, _appSynchMutexName+"1", 0, ref _
  _holdAppSynchMutex1);
 
				// Closedown system threads
				if (!_noSubTasks) // Test constant - see top of code
				{
					NWDist.DistMgr.PostDistClosedown();
					if (CThreadManager.ThreadMgr!=null) CThreadManager.ThreadMgr.DoCloseDown1( _
  5);
				}
 
				// Force closedown system threads
				if (!_noSubTasks) // Test constant - see top of code
					if (CThreadManager.ThreadMgr!=null) CThreadManager.ThreadMgr.DoCloseDown2( _
  3);
 
				// Save any active sessions in case ASP simply restarted us (it does things _
  like that)
				if ((!_noRestart)&&(_configRestartDelay!=0)) // Test constant - see top of _
code
				{
					saveSessions();
					if (CTrace.TraceOn) CTrace.Trace1("Config save data at:" & _
  ""+_configSaveFilePath, "SrvrApp");
					if (File.Exists(_configSaveFilePath))
					{
						// Ensure up-to-date timestamp for resart
						DateTime now = DateTime.Now;
						File.SetLastWriteTime(_configSaveFilePath, now);
						if (CTrace.TraceOn) CTrace.Trace1("Config save data lwt at:" & _
  ""+_configSaveFilePath+ "set to: "+now.ToLongTimeString(), "SrvrApp");
					}
				}
 
				// Optionally write Out Object Usage at Application End
				if (Config.ObjectStats)
					NWStats.WriteObjectUsageStats("(AppTermination)");
 
				// Free the second app synchronisation mutex
				FreeMutex(_appSynchMutex1, _appSynchMutexName+"1", ref _holdAppSynchMutex1); 
 
				// Close mutex objects
				if (_appSynchMutex!=null) _appSynchMutex.Close();
				if (_appSynchMutex1!=null) _appSynchMutex1.Close();
 
				// Close trace file
				if (_trace!=null)
				{
					if (CTrace.TraceOn) CTrace.Trace1("Closing trace file", "SrvrApp");
					// Global trace off
					CTrace.SetTrace(false);
					_trace.Close();
				}
 
				// Close the event log
				if (_eventLog!=null) _eventLog.Close();
 
			}
			catch(System.Exception ex)
			{
				ThreadError(ex, "XXApplication", "TermApplication", "Error in" & _
  "TermApplication");
			}
			finally
			{
				// Free the second app synchronisation mutex
				FreeMutex(_appSynchMutex1, _appSynchMutexName+"1", ref _holdAppSynchMutex1); 
 
				// Note: following message will only appear in default trace
				if (CTrace.TraceOn) CTrace.Trace1("Application termination complete", _
  "SrvrApp");
			}
		} // TermApplication
 
		// Perform request initiation
		// This is the main request start code for the application called from
		// global.asax.BeginRequest()
		public void BeginRequest(System.Web.HttpContext context)
		{
 
 
 
// noch ganz ganz viele Zeilen
 
 
		} // Property SessionCacheCount
 
		// Check whether Garbage Collection required and perform it
		// if necessary
		internal void CheckGC()
		{
			const int memFactor = 1024*1024;
 
			// Prevent multiple GCs with RequestGC option
			lock(this)
			{
				// Process memory level calling GC if required
				long tmb = GC.GetTotalMemory(false);
				long tma = 0;
				int cmb = Config.MemoryLevel;
				int cma = Config.MemoryLevel;
				long cm = cmb*memFactor;
				int gcTime = 0;
 
				if (CTrace.TraceOn)
				{
					CTrace.Trace1("CheckGC used storage: "+tmb.ToString("#,##0"), "SrvrApp");
					CTrace.Trace1("CheckGC tu: "+NWStats.DataTransferredUp.ToString("#,##0")+
						" td: "+NWStats.DataTransferredDown.ToString("#,##0"), "SrvrApp");
				}
				if (cm!=0&&tmb>=cm)
				{
					// Perform Garbage Collection measuring time
					DateTime dtsb = DateTime.Now;
					GC.Collect();
					DateTime dtsa = DateTime.Now;
					gcTime = (dtsa-dtsb).Milliseconds;
					tma = GC.GetTotalMemory(false);
 
					// If necessary, adjust MemoryLevel in Config
					if (tma>=cm)
					{
						cma += (int)(tma+memFactor)/(2*memFactor);
						Config.MemoryLevel = cma;
					}
 
					// Log GC message
					string gcm = string.Format("XXApp Forced Memory Collection at:" & _
  ""+DateTime.Now.ToString()+" GC Time: "+gcTime.ToString()+" ms\r\n"+
						"Memory before: {0:#,##0} Memory after: {1:#,##0} Config MemoryLevel" & _
"before: {2} Config MemoryLevel after: {3}", new object[] {tmb, tma, cmb, cma});
					WriteLog(gcm, NWConsts.event_warning, NWConsts.Event_Id_GC_Record, 0);
					if (CTrace.TraceOn) CTrace.Trace1("CheckGC after GC used storage:" & _
  ""+tma.ToString("#,##0"), "SrvrApp");
				}
				else
					if (CTrace.TraceOn) CTrace.Trace1("CheckGC no GC", "SrvrApp");
			} // lock()
		} // CheckGC()
 
		// Some stuff basically for testing session handling code
 
		// Test!
		internal void ListSessionCache()
		{
			if (!CTrace.TraceOn) return; 
			int cc = 0;
			int nwc = 0;
			try
			{
				CTrace.Trace2("List Session Cache entries", "SrvrApp");
				foreach(System.Collections.DictionaryEntry de in _appCache)
				{
					//if (CTrace.TraceOn) CTrace.Trace1("Cache entry "+(++cc).ToString()+"" & _
  "key: "+de.Key, "SrvrApp");
					//if (CTrace.TraceOn) CTrace.Trace1("Cache object type: "+de.Value.GetType( _
).FullName, "SrvrApp");
					if (de.Value is NWSession)
					{
						CTrace.Trace2("Session cache entry:"+(++cc).ToString(), "SrvrApp");
						DisplaySession((NWSession)de.Value, "Session cache list");
						nwc++; 
					}
				}
				if (nwc==0) CTrace.Trace2("No NWSession objects in cache", "SrvrApp");
			}
			catch{}
		} // ListSessionCache
 
		// Test!
		internal void ListUserCache()
		{
			if (!CTrace.TraceOn) return;
			int cc = 0;
			int nwc = 0;
			try
			{
				CTrace.Trace2("List User Cache entries", "SrvrApp");
				foreach(CServerUserInfo ui in _nwusersCache.Values)
				{
					CTrace.Trace2("User Cache entry:"+(++cc).ToString()+" userid:" & _
  ""+ui.ItemNum, "SrvrApp");
					nwc++; 
				}
				if (nwc==0) CTrace.Trace2("No User objects in cache", "SrvrApp");
			}
			catch{}
		}
 
	} // Class XXApplication
}

________
Alle Angaben ohne Gewähr. Keine Haftung für Vorschläge, Tipps oder sonstige Hilfe, falls es schiefgeht, nur Zeit verschwendet oder man sonst nicht zufrieden ist