An example of using CreateDomain in Visual C#

Make Code 128 Code Set C in Visual C# An example of using CreateDomain

using System; using System.Threading; using System.Security.Policy; namespace AppDomainTest1 { class ClassAppDomainTest { [STAThread] static void Main(string[] args) { Console.WriteLine("Enter Main"); ClassAppDomainTest c = new ClassAppDomainTest(); c.Main(); } void Main() { AppDomain current; current = AppDomain.CurrentDomain;

Thread.CurrentThread.Priority = ThreadPriority.BelowNormal; object o= current.GetData("autostart"); if (o == null) { Thread otherThread; otherThread = new Thread(new ThreadStart(NewThread)); otherThread.Start(); current.SetData("autostart",false); current.ExecuteAssembly("AppDomainTest1.exe"); } Thread.Sleep(1000); string message; message=string.Format(" {0}",current.FriendlyName); Console.WriteLine(message); } void NewThread() { AppDomain otherDomain; otherDomain = AppDomain.CreateDomain("otherDomain"); otherDomain.SetData("autostart",false); otherDomain.ExecuteAssembly("AppDomainTest1.exe"); } } }

This program produces the following output:

The first Enter Main statement occurs when the program is initially loaded. The first thing the main thread does is create an instance of the class containing the static Main method and invokes the instance s Main method. This is a common way of overcoming the need for a static entry point into a console-based program. The CreateDomain method that creates a domain and names it the specified name. In this case the new domain inherits its security and evidence from the current domain.

A thread is a path of execution. Every program contains at least one thread. .NET differentiates between logical and physical threads. As we discussed in chapter 2, a physical thread is an OS thread. Just as the OS manages other resources it manages physical threads. .NET introduces the concept of a logical thread. A logical thread is managed by the .NET framework and provides additional functionality beyond a physical thread.

Logical threads Under the Win32 implementation of .NET there is a one-for-one mapping between physical threads and logical threads. When additional platforms are supported by .NET it is very possible that there may be more than one logical thread associated with each physical thread. For example, if an OS didn t provide support for multiple physical threads in a process, the .NET runtime might supply that functionality using logical threads. Logical threads in .NET are accessed using the System.Threading namespace. Threading namespace The Threading namespace contains the classes associated with creating threads under managed code. Table 3.1 contains the most important classes in the Threading namespace.

Table 3.1 Class AutoResetEvent Interlocked ManualResetEvent Monitor Commonly used classes in the Threading namespace Description A synchronization mechanism that resets itself from the signaled state. A class that provides access to simple atomic operations. A synchronization mechanism that stays in the signaled state until it is explicitly reset. One of the most commonly used synchronization mechanisms. It allows for restriction of access to an object. A class that allows for the creation of mutually exclusive blocks of code. A class that allows for multiple readers and a single writer. This allows for high-performance solutions when the majority of the access to a data element is to read a value. Section/ Discussed 8.2 7 .2 8.4 7 .4

8.5 9

SynchronizationLockException An exception that s raised when an attempt is made to access a Monitor class method that requires synchronization while not in a synchronized block of code. Thread ThreadAbortException ThreadExceptionEventArgs ThreadInterruptedException A class that contains methods for creating and manipulating logical threads.

An exception that s raised when a thread is termi- 13.2.1 nated using the Abort method of the Thread class. A class that contains data used when a ThreadException occurs. An exception that s raised when a thread is interrupted using the Interrupt method of the Thread class. 12.4 13.2.2

Commonly used classes in the Threading namespace (continued) Description A class that provides an easy way of performing multithreaded operations by reusing multiple threads. An exception that s raised when the thread is in a state that is invalid for a particular method. A class that contains a static public field used to represent an infinite wait. A means of executing a method at a regular interval. A base class that provides a means of restricting access to a resource by having one or more threads wait for it to become available. A structure used to store lock information when a lock is converted from a reader lock to a writer lock. A delegate used to represent a method that is the entry point for a new thread. A delegate used with the Timer class to define the method that s executed when the Timer s timeout occurs. A class that is used with a ThreadPool class to enter a work item into the queue. A class that is used with a WaitHandle derived class. It is invoked when the WaitHandle class becomes signaled or a timeout occurs. An enumeration that indicates the threading state of an apartment. An enumeration that contains the priorities a thread can be assigned. An enumeration that contains the valid states a thread can be in. Section/ Discussed 10