怎么没有C#模板啊？论坛里面有群么？

shun7fire

怎么没有C#模板啊？论坛里面有群么？

shun7fire

没人回答么？

shun7fire

自己给自己顶！

shun7fire

人呢？出来

shun7fire

folklore

有噬，  m:n线程模板

1. // -- Multi-threads --
   
2. namespace ntrt
   
3. {
   
4.     /// <summary>
   
5.     ///     -- sample code (parallel exec with 64 threads) --
   
6.     ///        ntrt.ThreadAddress<int, int> thstart = delegate(int obj)
   
7.     ///        {
   
8.     ///            Console.Write(string.Format("{0}\n", obj));
   
9.     ///            return obj;
   
10.     ///        };
    
11. 
    
12.     ///        ntrt.ParallelThread<int, int> thrds = new ntrt.ParallelThread<int, int>();
    
13.     ///        for (int iC = 0; iC < 2048; iC++)
    
14.     ///        {
    
15.     ///            thrds.Add(thstart, iC);
    
16.     ///        }
    
17.     ///        int[] rts = ntrt.ParallelThread<int, int>.wait(thrds.exec(64));   //Environment.ProcessorCount *8);
    
18.     ///        Console.WriteLine("\n-------------------------------------------------");
    
19.     ///        foreach(int iret in rts){
    
20.     ///            Console.Write(string.Format("{0}\n",iret));
    
21.     ///        }
    
22.     /// </summary>
    
23.     /// <typeparam name="TRET">return value type</typeparam>
    
24.     /// <typeparam name="TPARAM">parameter type</typeparam>
    
25.     public delegate TRET ThreadAddress<TRET, TPARAM>(TPARAM obj); // where TRET : class;
    
26.     public delegate void FinishEventHandler<TRET, TPARAM>(ParallelThread<TRET, TPARAM> sender, TPARAM args, TRET ret, params object[] envs);
    
27.     public class ParallelThread<TRET, TPARAM> : List<KeyValuePair<ThreadAddress<TRET, TPARAM>, TPARAM>>
    
28.     {
    
29.         private const int IDX_SELF = 0;
    
30.         private const int IDX_NPARALLEL = 1;
    
31.         private const int IDX_COUNTER = 2;
    
32.         private const int IDX_RETURNS = 3;
    
33.         //private const int IDX_HANDLE = 1;
    
34. 
    
35.         public object exec(int nThread, TRET defBadRetval, params object[] envs)
    
36.         {
    
37.             this.isCancelled = false;
    
38.             ParameterizedThreadStart inner_start = delegate (object argobj)
    
39.             {
    
40.                 object[] arglist = argobj as object[];
    
41.                 System.Diagnostics.Debug.Assert(arglist.Length == 4);
    
42.                 System.Diagnostics.Debug.Assert(arglist[IDX_SELF] is ParallelThread<TRET, TPARAM>);
    
43.                 //System.Diagnostics.Debug.Assert(arglist[IDX_HANDLE] is IntPtr);
    
44.                 System.Diagnostics.Debug.Assert(arglist[IDX_NPARALLEL] is int);
    
45.                 System.Diagnostics.Debug.Assert(arglist[IDX_COUNTER] is InnerCounter);
    
46.                 System.Diagnostics.Debug.Assert(arglist[IDX_RETURNS] is TRET[]);
    
47. 
    
48.                 ParallelThread<TRET, TPARAM> thrds = arglist[IDX_SELF] as ParallelThread<TRET, TPARAM>;
    
49.                 //IntPtr hGcHandle = (IntPtr)arglist[IDX_HANDLE];
    
50.                 int nThreads = (int)arglist[IDX_NPARALLEL];
    
51.                 InnerCounter counter = (InnerCounter)arglist[IDX_COUNTER];
    
52.                 TRET[] retvals = arglist[IDX_RETURNS] as TRET[];
    
53.                 do
    
54.                 {
    
55.                     int iCount = 0;
    
56.                     lock (counter)
    
57.                     {
    
58.                         counter.iCount++;
    
59.                         iCount = counter.iCount;
    
60.                     }
    
61.                     //int iCount = Interlocked.Increment(ref counter.iCount);   //<- C# is unreliable... :-(.
    
62. 
    
63.                     if (iCount < counter.nCount)
    
64.                     {
    
65.                         if (thrds[iCount].Key != null)
    
66.                         {
    
67.                             retvals[iCount] = thrds[iCount].Key(thrds[iCount].Value);
    
68.                             if (thrds.Onfinished != null)
    
69.                             {
    
70.                                 thrds.Onfinished(thrds, thrds[iCount].Value, retvals[iCount], envs);
    
71.                             }
    
72.                         }
    
73.                     }
    
74.                     else
    
75.                     {
    
76.                         break;
    
77.                     }
    
78.                 } while (this.isCancelled == false);
    
79. 
    
80.                 int nComplete = 0;
    
81.                 lock (counter)
    
82.                 {
    
83.                     counter.nComplete++;
    
84.                     nComplete = counter.nComplete;
    
85.                 }
    
86.                 if (nComplete == nThreads)
    
87.                 {
    
88.                     if (thrds.OnCompeleted != null)
    
89.                     {
    
90.                         thrds.OnCompeleted(thrds, new EventArgs());
    
91.                     }
    
92.                 }
    
93.             };
    
94. 
    
95.             TRET[] rets = new TRET[this.Count];
    
96.             for (int iRet = 0; iRet < rets.Length; iRet++)
    
97.             {
    
98.                 rets[iRet] = defBadRetval;
    
99.             }
    
100. 
     
101.             int nRealThread = nThread;
     
102.             if (nRealThread > this.Count)
     
103.             {
     
104.                 nRealThread = this.Count;
     
105.             }
     
106.             InnerCounter ic = new InnerCounter() { iCount = -1, nComplete = 0, nCount = this.Count };
     
107.             Thread[] threads = new Thread[nRealThread];
     
108.             for (int iThd = 0; iThd < threads.Length; iThd++)
     
109.             {
     
110.                 threads[iThd] = new Thread(inner_start);
     
111.                 threads[iThd].Start(new object[] { this, nRealThread, ic, rets });
     
112.             }
     
113. 
     
114.             return new object[] { rets, threads } as object;
     
115. 
     
116.             //GCHandle gh = GCHandle.Alloc(new object[] { rets, threads });
     
117.             //IntPtr hgh = GCHandle.ToIntPtr(gh);
     
118.             //return hgh;
     
119.         }//end function: exec
     
120. 
     
121.         public void Add(ThreadAddress<TRET, TPARAM> thaddr, TPARAM args)
     
122.         {
     
123.             this.Add(new KeyValuePair<ThreadAddress<TRET, TPARAM>, TPARAM>(thaddr, args));
     
124.         }
     
125.         public bool isCancelled { set; get; }
     
126.         public event FinishEventHandler<TRET, TPARAM> Onfinished;
     
127.         public event EventHandler OnCompeleted;
     
128.         public object UserData { set; get; }
     
129. 
     
130.         // -- Helper function --
     
131.         public void abort(object h)
     
132.         {
     
133.             object[] args = h as object[];
     
134. 
     
135.             System.Diagnostics.Debug.Assert(args.Length == 2);
     
136.             System.Diagnostics.Debug.Assert(args[0] is TRET[]);
     
137.             System.Diagnostics.Debug.Assert(args[1] is Thread[]);
     
138.             foreach (Thread thd in args[1] as Thread[])
     
139.             {
     
140.                 try
     
141.                 {
     
142.                     thd.Abort();
     
143.                 }
     
144.                 catch (Exception ex)
     
145.                 {
     
146.                     System.Diagnostics.Debug.Assert(ex != null);
     
147.                 }
     
148.             }
     
149. 
     
150.             if (this.OnCompeleted != null)
     
151.             {
     
152.                 this.OnCompeleted(this, new EventArgs());
     
153.             }
     
154.         }
     
155.         public static TRET[] wait(object h)
     
156.         {
     
157.             object[] args = h as object[];
     
158. 
     
159.             System.Diagnostics.Debug.Assert(args.Length == 2);
     
160.             System.Diagnostics.Debug.Assert(args[0] is TRET[]);
     
161.             System.Diagnostics.Debug.Assert(args[1] is Thread[]);
     
162. 
     
163.             Thread[] threads = args[1] as Thread[];
     
164.             foreach (Thread thd in threads)
     
165.             {
     
166.                 thd.Join(); //<- Wait for all thread exits
     
167.             }
     
168. 
     
169.             TRET[] rets = args[0] as TRET[];
     
170.             return rets;
     
171.         }//end function: wait
     
172. 
     
173.         public static int nLogicCPUCores { get { return Environment.ProcessorCount; } }
     
174.         private class InnerCounter
     
175.         {
     
176.             public volatile int iCount = 0;
     
177.             public int nCount = 0;
     
178.             public volatile int nComplete = 0;
     
179.         }
     
180.     }//end class: class ParallelThread<TRET, TPARAM>
     
181. }//end namespace: ntrt
     

复制代码

truekbcl

c#的泛型没啥好说的，非图灵完备，基本就是一坨屎。没有分支没有赋值，神马都玩不出来。

fender0107401

Unix-Like下面能写C#吗？