C#

public partial class Employee
{
    public void DoWork()
    {
    }
}

public partial class Employee
{
    public void GoToLunch()
    {
    }
}

faraz34 wrote:

How can we write the long source of a program in

2 or 3 files and relate them together at build time.

jschell wrote:

3. In C# you put all of the classes in a project which is then managed via a
solution.

csc /out:My.exe *.cs

Bastard Programmer from Hell

csc MyFirstClass.cs MySecondClass.cs etc.cs

Thread T1 = new Thread(new ParameterizedThreadStart(Y));
T1.Start(42);
...
public static void Y(object i) { Console.WriteLine("Hello: "+ i); }

public static void Y(double a, DateTime[] myDates, Dictionary<string,double> myDic)

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading;



namespace mtquestion

{

    class Program

    {

       

        static void Main(string[] args)

        {



           

            Thread T1 = new Thread(new ParameterizedThreadStart(C));

            Thread T2 = new Thread(new ParameterizedThreadStart(C));

            Thread T3 = new Thread(new ParameterizedThreadStart(C));

         



            

            T1.Start(15000000);

            T2.Start(25000000);

            T3.Start(60000);



           

            T1.Join();

            T2.Join();

            T3.Join();

        

            Console.WriteLine("All 3 done");



        }



        //dummy function to spend time

        public static void C(object i) 

        {

            

           double y = 0.0;

            for (int j = 1; j<(int) i; j++)

            {

                y += Math.Log(Math.Exp(0.06)) * Math.Log(Math.Exp(0.06)) / Math.Log(Math.Exp(0.06)) * Math.Log(Math.Exp(0.06)); 

            }

            

            Console.WriteLine(i);

        }

        public static void Total(object j) 

        {

        //..... sum y of each
 C(..) when conclueded
        }

			

    }

}

class Job {
    private int parm1;
    private int parm2;
    public int Result;
    private Thread thread;

    public Job(int parm1, int parm2) {
        this.parm1=parm1;
        this.parm2=parm2;
    }

    public void Run() {
        thread=new Thread(new ThreadStart(runner));
        thread.Start();
    }

    public void Join() {
        thread.Join();
    }

    private void runner() {
        Result=parm1+parm2;
    }
}

class Test {
    public static Main() {
        List<Job> jobs=new List<Job>();
        for(int i=0; i<10; i++) {
            Job job=new Job(3*i, i+12);
            jobs.Add(job);
            job.Run();
        }
        foreach(Job job in jobs) job.Join();
        int total=0;
        foreach(Job job in jobs) total+=job.Result;
    }
}

Luc Pattyn wrote:

Atomic here means the data operation is performed by a single assembler instruction,

add dword ptr[esp+0x20], eax
inc dword ptr[edi]
; other r-m-w instructions

Luc Pattyn wrote:

so if two ints need to represent a consistent state, then you also would need a lock

class MyTask {
 double a,b;
 Thread t;
 ManualResetEvent wh;

 ManualResetEvent WaitHandle { get { return wh; } }
 public Thread Thread { get { return t; } }

 MyTask(double a, double b) {
  this.a = a; this.b = b; 
  t = new Thread(new ThreadStart(Run));
  wh = new ManualResetEvent();
 }

 private void Run(){
  // do whatever with a and b
  wh.Signal();
 }
}

Thread thread = new MyTask(11, 15).Thread;
thread.Start();

MyTask task = new MyTask(11, 15);
task.Thread.Start();
task.WaitHandle.WaitOne();