diff --git a/CSharpTranslator/tests/Tester/Delegates/DelegateUser.cs b/CSharpTranslator/tests/Tester/Delegates/DelegateUser.cs old mode 100644 new mode 100755 diff --git a/CSharpTranslator/tests/Tester/Main.cs b/CSharpTranslator/tests/Tester/Main.cs index 97597fe..aee0f3c 100644 --- a/CSharpTranslator/tests/Tester/Main.cs +++ b/CSharpTranslator/tests/Tester/Main.cs @@ -15,9 +15,10 @@ namespace Tester //Tester.Delegates.EventHandler.Sample.EHMain(); // Tester.Misc.RenameTest.RNMain("hello world"); - Tester.Misc.Sorter.Example.SorterMain(); - Tester.Misc.RegexTest.RegexMain(); - + //Tester.Misc.Sorter.Example.SorterMain(); + //Tester.Misc.RegexTest.RegexMain(); + Twiglet.Sample.Delegate.DelegateSampler.DelegateSamplerMain(); + Console.WriteLine("Finished"); } } } diff --git a/CSharpTranslator/tests/Tester/Tester.csproj b/CSharpTranslator/tests/Tester/Tester.csproj index 1afd67f..13ab7f4 100644 --- a/CSharpTranslator/tests/Tester/Tester.csproj +++ b/CSharpTranslator/tests/Tester/Tester.csproj @@ -1,4 +1,4 @@ - + Debug @@ -41,6 +41,7 @@ + @@ -54,7 +55,7 @@ - + @@ -62,8 +63,5 @@ - - - - + \ No newline at end of file diff --git a/CSharpTranslator/tests/Tester/WebDelegates/DelegateSampler.cs b/CSharpTranslator/tests/Tester/WebDelegates/DelegateSampler.cs new file mode 100755 index 0000000..1e8f912 --- /dev/null +++ b/CSharpTranslator/tests/Tester/WebDelegates/DelegateSampler.cs @@ -0,0 +1,175 @@ +// Copyright 2011 Kevin Glynn (http://www.twigletsoftware.com) +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +using System; +using System.Collections.Generic; + +namespace Twiglet.Sample.Delegate +{ + + /// + /// Sample class to show off CS2J's translations for delegates and events + /// + public class DelegateSampler + { + public delegate void xProcessor(ref T value); + // + /// + /// LogWriters take a string and record it. + /// + /// the message to be recorded + public delegate void LogWriter(string logMessage); + + /// + /// A chain of delegates can't pass values to each other, (the value + /// returned from the final delegate is returned to the caller, but the + /// values from intermediate delegates are just dropped on the floor). + /// However the delegates can communictae if we use ref parameters. + /// + /// the variable that we are processing + public delegate void Processor(ref T value); + + // This variable is captured by the delegates, if we change this variable + // then it changes what they print. + private string _captured_string = "none"; + + private void MethodDelegate(string s) + { + Console.WriteLine("MethodDelegate[" + _captured_string + "]:\t\t\t" + s); + } + + private void MethodDelegateTwo(string s) + { + Console.WriteLine("MethodDelegateTwo[" + _captured_string + "]:\t\t" + s); + } + + public void RunIt() { + + // First we create some delegates using the many syntaxes supported by C# + + // Old fashioned delegate creation + // initialize delegate with a named method. + LogWriter delA = new LogWriter(MethodDelegate); + + // We can just also just assign a method group to a delegate variable + LogWriter delB = MethodDelegateTwo; + + // Since C# 2.0 a delegate can be initialized with + // an "anonymous method." + LogWriter delC = delegate(string s) { Console.WriteLine("AnonymousMethodDelegate[" + _captured_string + "]:\t\t" + s); }; + + // Since C# 3.0 a delegate can be initialized with + // a lambda expression. + LogWriter delD = (string s) => { Console.WriteLine("LambdaExpressionDelegate[" + _captured_string + "]:\t\t" + s); }; + + // Since C# 3.0 a delegate can be initialized with + // a lambda expression, the type of the argument is inferred by the compiler. + LogWriter delE = s => { Console.WriteLine("InferredLambdaExpressionDelegate[" + _captured_string + "]:\t" + s); }; + + // Invoke the delegates. + delA("Peter Piper"); + delB("picked a peck"); + delC("of pickled peppers."); + delD("A peck of pickled peppers"); + delE("Peter Piper picked."); + + // Change the captured parameter and run them again + this._captured_string = "aaaa"; + + delA("Peter Piper"); + delB("picked a peck"); + delC("of pickled peppers."); + delD("A peck of pickled peppers"); + delE("Peter Piper picked."); + + // Now Combine the delegates + var chainDelegates = delA + delB + delC + delD + delE; + + // and invoke it + chainDelegates("Chained Delegates"); + + // remove delB and rerun + chainDelegates -= delB; + + chainDelegates("Chained without MethodDelegateTwo"); + + // Calculate (4 * (x^x)) + 1 + Processor calcIt = (ref int x) => { x = x*x; }; + calcIt += (ref int x) => { x = 4 * x; }; + calcIt += (ref int x) => { x += 1; }; + int val = 5; + calcIt(ref val); + Console.WriteLine("(4 * (5^5)) + 1 = " + val); + } + + delegate void DelC (string s); + + static void Hello (string s) + { + System.Console.WriteLine (" Hello, {0}!", s); + } + + static void Goodbye (string s) + { + System.Console.WriteLine (" Goodbye, {0}!", s); + } + + void HelloGoodbye () + { + DelC a, b, c, d; + + // Create the delegate object a that references + // the method Hello: + a = Hello; + + // Create the delegate object b that references + // the method Goodbye: + b = Goodbye; + + // The two delegates, a and b, are composed to form c: + c = a + b; + + // Remove a from the composed delegate, leaving d, + // which calls only the method Goodbye: + d = c - a; + + System.Console.WriteLine ("Invoking delegate a:"); + a ("A"); + System.Console.WriteLine ("Invoking delegate b:"); + b ("B"); + System.Console.WriteLine ("Invoking delegate c:"); + c ("C"); + System.Console.WriteLine ("Invoking delegate d:"); + d ("D"); + + + d += c; + + d += c; + + d -= c; + + System.Console.WriteLine ("Invoking composed delegate d:"); + d ("DA"); + + } + + + public static void DelegateSamplerMain() + { + DelegateSampler sampler = new DelegateSampler (); + sampler.RunIt(); + } + } +}