//***************Threading******************************************************

Thread t = new Thread(new ThreadStart(DoWork)); //Methode->protected void DoWork() t.Start();

System.Threading.Thread.Sleep(5000);

//**************BackgroundWorker(Beispiel)********************

private BackgroundWorker bw = new BackgroundWorker(); public Page()

{
InitializeComponent();
bw.WorkerReportsProgress = true;
bw.WorkerSupportsCancellation = true;
bw.DoWork += new DoWorkEventHandler(bw_DoWork);
bw.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged); bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted); }
private void buttonStart_Click(object sender, RoutedEventArgs e)
{
if (bw.IsBusy != true)
{
bw.RunWorkerAsync();
}
}
private void buttonCancel_Click(object sender, RoutedEventArgs e)
{
if (bw.WorkerSupportsCancellation == true)
{
bw.CancelAsync();
}
}
private void bw_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = sender as BackgroundWorker;

for (int i = 1; (i <= 10); i++)
{
if ((worker.CancellationPending == true))
{
e.Cancel = true;
break;
}
else
{
System.Threading.Thread.Sleep(500);
worker.ReportProgress((i * 10));
}
}
}
private void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {
if ((e.Cancelled == true))
{
this.tbProgress.Text = "Canceled!";
}

else if (!(e.Error == null))
{
this.tbProgress.Text = ("Error: " + e.Error.Message); }

else

{
this.tbProgress.Text = "Done!";
}
}
private void bw_ProgressChanged(object sender, ProgressChangedEventArgs e) {
this.tbProgress.Text = (e.ProgressPercentage.ToString() + "%");

// Perform a time consuming operation and report progress.

} }

//******************Delegate(Beispiel)******************************

using System.IO public class Program {

public delegate void Write(string theText);
public static void OutputToScreen(string theText)

{ Console.WriteLine(theText);

}

public static void WriteToFile(string theText) {

// Define our delegate type
// Method for output to screen

// Method to output to file

StreamWriter fileWriter = File.CreateText("c:/delegate-demo.txt"); fileWriter.WriteLine(theText);
fileWriter.Flush();
fileWriter.Close();

}
public static void Main() {

Write toFile = new Write(WriteToFile);
Write toScreen = new Write(OutputToScreen); Display("This is a delegate demo", toFile); Display("This is a delegate demo", toScreen);

// Assign a method to a delegate

}
public static void Display(string theText, Write outputMethod) {

outputMethod(theText); }

}

//************************Delegate(Beispiel2)***********************

//Step 1. Declare a delegate with the signature of the encapsulated method

public delegate void MyDelegate(string input);
//Step 2. Define methods that match with the signature of delegate declaration
class MyClass1
{
public void delegateMethod1(string input)
{
Console.WriteLine("This is delegateMethod1 and the input to the method is {0}",input); }
public void delegateMethod2(string input)
{
Console.WriteLine("This is delegateMethod2 and the input to the method is {0}",input); }
}
//Step 3. Create delegate object and plug in the methods
class MyClass2
{
public MyDelegate createDelegate()
{
MyClass1 c2=new MyClass1();
MyDelegate d1 = new MyDelegate(c2.delegateMethod1);
MyDelegate d2 = new MyDelegate(c2.delegateMethod2);
MyDelegate d3 = d1 + d2;
return d3;
}
}
//Step 4. Call the encapsulated methods through the delegate
class MyClass3
{
public void callDelegate(MyDelegate d,string input)
{
d(input);
}
}
class Driver
{
static void Main(string[] args)
{
MyClass2 c2 = new MyClass2();
MyDelegate d = c2.createDelegate();
MyClass3 c3 = new MyClass3();
c3.callDelegate(d,"Calling the delegate");
}

}

//********************Delegate(Beispiel3)*****************

namespace SimpleDelegateSample {

public delegate int Calculate (int value1, int value2); //defining the delegate
public class MyClass //the class which contains the methods that will be assigned to delegate objects

{

public MyClass() { }
public int add(int value1, int value2) {

return value1 + value2;

}
public int sub( int value1, int value2) {

return value1 - value2;

} }

class Program {

static void Main(string[] args)
{
MyClass mc = new MyClass();
Calculate add = new Calculate(mc.add); //creating delegate objects and assigning appropriate methods Calculate sub = new Calculate(mc.sub);

//creating the class which contains the methods that will be assigned to delegate objects

Console.WriteLine("Adding two values: " + add(10, 6)); Console.WriteLine("Subtracting two values: " + sub(10,4)); Console.ReadLine();
}

//using the delegate objects to call the assigned methods

} }

//********************Event*********************************

public delegate void MyHandler1(object sender,MyEventArgs e); //Step 1 Create delegate object public delegate void MyHandler2(object sender,MyEventArgs e);

class A {

//Step 2 Create event handler methods

} }

class B {

{

} }

public const string m_id="Class A";
public void OnHandler1(object sender,MyEventArgs e) {

Console.WriteLine("I am in OnHandler1 and MyEventArgs is {0}", e.m_id);

}
public void OnHandler2(object sender,MyEventArgs e) {

Console.WriteLine("I am in OnHandler2 and MyEventArgs is {0}", e.m_id);

}
public A(B b) //Step 3 create delegates, plug in the handler and register with the object that will fire the events {

MyHandler1 d1=new MyHandler1(OnHandler1); MyHandler2 d2=new MyHandler2(OnHandler2); b.Event1 +=d1;
b.Event2 +=d2;

//Step 4 Calls the encapsulated methods through the delegates (fires events)

public event MyHandler1 Event1; public event MyHandler2 Event2; public void FireEvent1(MyEventArgs e) {

if(Event1 != null) {

Event1(this,e); public void FireEvent2(MyEventArgs e)

} }

public class MyEventArgs : EventArgs {

public string m_id;

}
public class Driver {

if(Event2 != null) {
Event2(this,e);
}

} }

public static void Main() {

B b= new B();
A a= new A(b);
MyEventArgs e1=new MyEventArgs(); MyEventArgs e2=new MyEventArgs(); e1.m_id ="Event args for event 1"; e2.m_id ="Event args for event 2"; b.FireEvent1(e1);
b.FireEvent2(e2);

//*****************Event(Beispiel2)*************************************

public class MyEventArgs : EventArgs {

private string msg;

public MyEventArgs( string messageData ) {

msg = messageData; }

public string Message {

get { return msg; }

set { msg = value; } }

}
public class HasEvent {

public event EventHandler<MyEventArgs> SampleEvent;

public void DemoEvent(string val) {

EventHandler<MyEventArgs> temp = SampleEvent; if (temp != null)

temp(this, new MyEventArgs(val)); }

}
public class Sample {

public static void Main() {

// Declare an event of delegate type EventHandler of MyEventArgs.

// Copy to a temporary variable to be thread-safe.

HasEvent he = new HasEvent();
he.SampleEvent += new EventHandler<MyEventArgs>(SampleEventHandler); he.DemoEvent("Hey there, Bruce!");
he.DemoEvent("How are you today?");

}
private static void SampleEventHandler(object src, MyEventArgs mea) {

Console.WriteLine(mea.Message); }

} //***********************************************