C#学习笔记

一：调用DLL

 //puts 函数的参数的默认封送处理从默认值 LPTSTR 重写为 LPSTR
 [DllImport("msvcrt.dll")]
 public static extern int puts([MarshalAs(UnmanagedType.LPStr)] string m);
 [DllImport("msvcrt.dll")]
 internal static extern int _flushall();


 // 如果没加 EntryPoint 的话 函数名必须和DLL中的函数名一致
 [DllImport("TestDLL.dll", EntryPoint = "fnTestDLL")]
 public static extern int abc([MarshalAs(UnmanagedType.LPStr)]string m);

 static void Main(string[] args)
 {
     abc("asd");
     puts("Hello World!");
     _flushall();

     Console.Read();
 }

二：线程

public class Alpha
{
    public void Beta()
    {
        while(true)
        {
            Console.WriteLine("Alpha.Beta is running in its own thread");
        }
    }
};


Alpha oAlpha = new Alpha();
Thread oThread = new Thread(new ThreadStart(oAlpha.Beta));
oThread.Start();
while (!oThread.IsAlive) ;// 判断线程是否结束
Thread.Sleep(1);            // 放弃时间片
oThread.Abort();            // 关闭线程

oThread.Join();              // 阻塞等待线程结束

try
{
    // 线程不允许重新启动
    Console.WriteLine("Try to restart the Alpha.Beta thread");
    oThread.Start();
}
catch(ThreadStateException)
{
    Console.Write("ThreadStateException trying to restart Alpha.Beta. ");
    Console.WriteLine("Expected since aborted threads cannot be restarted.");
}

public class CellProd
{
    Cell cell;         // Field to hold cell object to be used
    int quantity = 1;  // Field for how many items to produce in cell

    public CellProd(Cell box, int request)
    {
        cell = box;          // Pass in what cell object to be used
        quantity = request;  // Pass in how many items to produce in cell
    }
    public void ThreadRun()
    {
        for (int looper = 1; looper <= quantity; looper++)
            cell.WriteToCell(looper);  // "producing"
    }
}

public class CellCons
{
    Cell cell;         // Field to hold cell object to be used
    int quantity = 1;  // Field for how many items to consume from cell

    public CellCons(Cell box, int request)
    {
        cell = box;          // Pass in what cell object to be used
        quantity = request;  // Pass in how many items to consume from cell
    }
    public void ThreadRun()
    {
        int valReturned;
        for (int looper = 1; looper <= quantity; looper++)
            valReturned = cell.ReadFromCell();
    }
}

public class Cell
{
    int cellContents;         // Cell contents
    bool readerFlag = false;  // State flag
    public int ReadFromCell()
    {
        lock (this)   // Enter synchronization block
        {
            if (!readerFlag)
            {
                // Waits for the Monitor.Pulse in WriteToCell
                Monitor.Wait(this);
            }
            Console.WriteLine("Consume: {0}", cellContents);
            readerFlag = false;    // Reset the state flag to say consuming is done.

            Monitor.Pulse(this);   // Pulse tells Cell.WriteToCell

}   // Exit synchronization block
        return cellContents;
    }

    public void WriteToCell(int n)
    {
        lock (this)  // Enter synchronization block
        {
            if (readerFlag)
            {
                Monitor.Wait(this);   // Wait for the Monitor.Pulse in
            }
            cellContents = n;
            Console.WriteLine("Produce: {0}", cellContents);
            readerFlag = true;    // Reset the state flag to say producing is done

            Monitor.Pulse(this);  // Pulse tells Cell.ReadFromCell

        }   // Exit synchronization block
    }




int result = 0;   // Result initialized to say there is no error
Cell cell = new Cell( );

CellProd prod = new CellProd(cell, 20);  // Use cell for storage, 
CellCons cons = new CellCons(cell, 20);  // Use cell for storage, 

Thread producer = new Thread(new ThreadStart(prod.ThreadRun));
Thread consumer = new Thread(new ThreadStart(cons.ThreadRun));

try
{
   producer.Start( );
   consumer.Start( );

   producer.Join( );   // Join both threads with no timeout
   consumer.Join( );  
}
catch (ThreadStateException e)
{
   result = 1;            // Result says there was an error
}
catch (ThreadInterruptedException e)
{
   result = 1;            // Result says there was an error
}
// Even though Main returns void, this provides a return code to the parent process.
Environment.ExitCode = result;

public class SomeState
{
    public int Cookie;
    public SomeState(int iCookie)
    {
        Cookie = iCookie;
    }
}

public class Alpha
{
    public Hashtable HashCount;
    public ManualResetEvent eventX;
    public static int iCount = 0;
    public static int iMaxCount = 0;
    public Alpha(int MaxCount)
    {
        HashCount = new Hashtable(MaxCount);
        iMaxCount = MaxCount;
    }

    public void Beta(Object state)
    {
        // Write out the hashcode and cookie for the current thread
        Console.WriteLine(" {0} {1} :", Thread.CurrentThread.GetHashCode(), ((SomeState)state).Coo
        // The lock keyword allows thread-safe modification of variables accessible across multipl
        Console.WriteLine("HashCount.Count=={0}, Thread.CurrentThread.GetHashCode()=={1}",
           HashCount.Count, Thread.CurrentThread.GetHashCode());
        lock (HashCount)
        {
            if (!HashCount.ContainsKey(Thread.CurrentThread.GetHashCode()))
                HashCount.Add(Thread.CurrentThread.GetHashCode(), 0);
            HashCount[Thread.CurrentThread.GetHashCode()] =
               ((int)HashCount[Thread.CurrentThread.GetHashCode()]) + 1;
        }

        // Do some busy work.
        // Note: Depending on the speed of your machine, if you 
        // increase this number, the dispersement of the thread
        // loads should be wider.
        int iX = 2000;
        Thread.Sleep(iX);
        // The Interlocked.Increment method allows thread-safe modification
        // of variables accessible across multiple threads.
        Interlocked.Increment(ref iCount);  //**********


        if (iCount == iMaxCount)
        {
            Console.WriteLine();
            Console.WriteLine("Setting eventX ");
            eventX.Set();
        }
    }
}



bool W2K = false;
int MaxCount = 10;

ManualResetEvent eventX = new ManualResetEvent(false);    // Mark the event as unsignaled.
Alpha oAlpha = new Alpha(MaxCount);

// Make sure the work items have a reference to the signaling event.
oAlpha.eventX = eventX;
Console.WriteLine("Queue to Thread Pool 0");
try
{
  // 第二个参数是 作为 oAlpha.Beta 的参数
  ThreadPool.QueueUserWorkItem(new WaitCallback(oAlpha.Beta), new SomeState(0));
   W2K = true;
}
catch (NotSupportedException)
{
   Console.WriteLine("These API's may fail when called on a non-Windows 2000 system.");
   W2K = false;
}
if (W2K)  // If running on an OS which supports the ThreadPool methods.
{
   for (int iItem=1;iItem < MaxCount;iItem++)
   {
      // Queue the work items:
      Console.WriteLine("Queue to Thread Pool {0}", iItem);
      ThreadPool.QueueUserWorkItem(new WaitCallback(oAlpha.Beta),new SomeState(iItem));
   }
   Console.WriteLine("Waiting for Thread Pool to drain");

   // Wait until event is fired, meaning eventX.Set() was called:
   eventX.WaitOne(Timeout.Infinite,true);
   // The WaitOne won't return until the event has been signaled.
   Console.WriteLine("Thread Pool has been drained (Event fired)");
   Console.WriteLine(); Console.WriteLine("Load across threads");
   foreach(object o in oAlpha.HashCount.Keys)
      Console.WriteLine("{0} {1}", o, oAlpha.HashCount[o]);
}

static Mutex gM1;
static Mutex gM2;
const int ITERS = 100;
static AutoResetEvent Event1 = new AutoResetEvent(false);
static AutoResetEvent Event2 = new AutoResetEvent(false);
static AutoResetEvent Event3 = new AutoResetEvent(false);
static AutoResetEvent Event4 = new AutoResetEvent(false);



public class MutexSample
{
    public static void Main(String[] args)
    {
        Console.WriteLine("Mutex Sample ...");
        // Create Mutex initialOwned, with name of "MyMutex".
        gM1 = new Mutex(true, "MyMutex");
        // Create Mutex initialOwned, with no name.
        gM2 = new Mutex(true);
        Console.WriteLine(" - Main Owns gM1 and gM2");

        AutoResetEvent[] evs = new AutoResetEvent[4];
        evs[0] = Event1;    // Event for t1
        evs[1] = Event2;    // Event for t2
        evs[2] = Event3;    // Event for t3
        evs[3] = Event4;    // Event for t4

        MutexSample tm = new MutexSample( );
        Thread t1 = new Thread(new ThreadStart(tm.t1Start));
        Thread t2 = new Thread(new ThreadStart(tm.t2Start));
        Thread t3 = new Thread(new ThreadStart(tm.t3Start));
        Thread t4 = new Thread(new ThreadStart(tm.t4Start));
        t1.Start( );   // Does Mutex.WaitAll(Mutex[] of gM1 and gM2)
        t2.Start( );   // Does Mutex.WaitOne(Mutex gM1)
        t3.Start( );   // Does Mutex.WaitAny(Mutex[] of gM1 and gM2)
        t4.Start( );   // Does Mutex.WaitOne(Mutex gM2)

        Thread.Sleep(2000);
        Console.WriteLine(" - Main releases gM1");
        gM1.ReleaseMutex( );  // t2 and t3 will end and signal

        Thread.Sleep(1000);
        Console.WriteLine(" - Main releases gM2");
        gM2.ReleaseMutex( );  // t1 and t4 will end and signal

        // Waiting until all four threads signal that they are done.
        WaitHandle.WaitAll(evs); 
        Console.WriteLine("... Mutex Sample");
    }

    public void t1Start( )
    {
        Console.WriteLine("t1Start started,  Mutex.WaitAll(Mutex[])");
        Mutex[] gMs = new Mutex[2];
        gMs[0] = gM1;  // Create and load an array of Mutex for WaitAll call
        gMs[1] = gM2;
        Mutex.WaitAll(gMs);  // Waits until both gM1 and gM2 are released
        Thread.Sleep(2000);
        Console.WriteLine("t1Start finished, Mutex.WaitAll(Mutex[]) satisfied");
        Event1.Set( );      // AutoResetEvent.Set() flagging method is done
    }

    public void t2Start( )
    {
        Console.WriteLine("t2Start started,  gM1.WaitOne( )");
        gM1.WaitOne( );    // Waits until Mutex gM1 is released
        Console.WriteLine("t2Start finished, gM1.WaitOne( ) satisfied");
        Event2.Set( );     // AutoResetEvent.Set() flagging method is done
    }

    public void t3Start( )
    {
        Console.WriteLine("t3Start started,  Mutex.WaitAny(Mutex[])");
        Mutex[] gMs = new Mutex[2];
        gMs[0] = gM1;  // Create and load an array of Mutex for WaitAny call
        gMs[1] = gM2;
        Mutex.WaitAny(gMs);  // Waits until either Mutex is released
        Console.WriteLine("t3Start finished, Mutex.WaitAny(Mutex[])");
        Event3.Set( );       // AutoResetEvent.Set() flagging method is done
    }

    public void t4Start( )
    {
        Console.WriteLine("t4Start started,  gM2.WaitOne( )");
        gM2.WaitOne( );   // Waits until Mutex gM2 is released
        Console.WriteLine("t4Start finished, gM2.WaitOne( )");
        Event4.Set( );    // AutoResetEvent.Set() flagging method is done
    }
}