Exemplo n.º 1
0
        /// <summary>
        /// The method encapsulating the code to be exemplified.
        /// </summary>
        public void Main()
        {
            // Define an operator that squares its operand
            Func <int, int> square = (int operand) => operand * operand;

            // Define an operand
            int integer = 2;

            // Operate on it
            Console.WriteLine("Squaring {0}...", integer);
            int result = IntegerOperation.Operate(square, integer);

            Console.WriteLine("...the result is {0}.", result);

            // Check that an operator cannot be null
            try
            {
                IntegerOperation.Operate(null, 0);
            }
            catch (Exception e)
            {
                Console.WriteLine();
                Console.WriteLine("Cannot apply a null function:");
                Console.WriteLine(e.Message);
            }
        }
Exemplo n.º 2
0
        public void ShouldBeAbleToAddNewMethod()
        {
            IntegerOperation addBody = delegate(int a, int b) { return(a + b); };
            var dynamic = new DynamicObject(new object());

            dynamic.AddMethod("Add", addBody);

            var result = (int)dynamic.Methods["Add"](1, 1);

            Assert.AreEqual(2, result);
        }
Exemplo n.º 3
0
        static void Main(string[] args)
        {
            IntegerOperation op0 = Sum;

            op0(1, 2);
            Console.WriteLine();

            op0 += Diff;
            op0(2, 3);
            Console.WriteLine();

            MultyTypeOperation <double, double> op1 = Concatenate;
            MultyTypeOperation <int, int>       op2 = Concatenate;

            op1.Invoke(1.1, 2.2);
            op2.Invoke(1, 2);
            Console.WriteLine();

            Action <int, int> op3 = Concatenate;

            op3(3, 4);
            Console.WriteLine();

            Predicate <int> IsPositive = (x) => x > 0;

            Console.WriteLine(IsPositive(6));
            Console.WriteLine();

            Func <int, int, double> op4 = (x, y) => { return((double)x + (double)y); };

            op4(2, 3);

            if (DateTime.Now.Hour < 12)
            {
                Show_Message(GoodMorning);
            }
            else
            {
                Show_Message(GoodEvening);
            }



            Console.ReadKey();
        }
        /// <summary>
        /// Applies the specified function to the given array of operands.
        /// </summary>
        /// <param name="func">The function to evaluate at each operand.</param>
        /// <param name="operands">The array of operands.</param>
        /// <returns>The results of the operations.</returns>
        /// <exception cref="ArgumentNullException">
        /// <paramref name="func"/> is <b>null</b>.<br/>
        /// -or-<br/>
        /// <paramref name="operands"/> is <b>null</b>.
        /// </exception>
        /// <example>
        /// <para>
        /// In the following example, the applied function, say
        /// <latex mode='inline'>f:\mathbb{N}\rightarrow \mathbb{N},</latex> is defined as
        /// <latex mode='display'>
        /// \forall n \in \mathbb{N}: n \mapsto f\left(n\right)=n^2.
        /// </latex>
        /// A plot of such function is displayed in the following
        /// figure.
        /// <image>
        /// <alt>A function.</alt>
        /// <src>Function.png</src>
        /// <width>100%</width>
        /// </image>
        /// Integers in a given array are thus squared
        /// executing the <see cref="Operate(Func{int, int}, int[])"/> method.
        /// In addition, input validation is also checked.
        /// </para>
        /// <para>
        /// <code language="cs">
        /// using System;
        /// using SampleClassLibrary.Advanced;
        ///
        /// namespace SampleClassLibrary.CodeExamples.Advanced
        /// {
        ///     public class IntegerArrayOperationExample
        ///     {
        ///         public void Main()
        ///         {
        ///             // Define an operator that squares its operand
        ///             Func<![CDATA[<]]>int, int> square = (int operand) => operand * operand;
        ///
        ///             // Define an array of operands
        ///             int[] operands = new int[3] { 2, 4, 8 };
        ///
        ///             // Operate on it
        ///             int[] results = IntegerArrayOperation.Operate(square, operands);
        ///
        ///             // Show results
        ///             for (int i = 0; i <![CDATA[<]]> results.Length; i++)
        ///             {
        ///                 Console.WriteLine(
        ///                     "The result of squaring {0} is {1}.",
        ///                     operands[i],
        ///                     results[i]);
        ///             }
        ///
        ///             // Check that an operator cannot be null
        ///             try
        ///             {
        ///                 IntegerArrayOperation.Operate(null, new int[1]);
        ///             }
        ///             catch (Exception e)
        ///             {
        ///                 Console.WriteLine();
        ///                 Console.WriteLine("Cannot apply a null function:");
        ///                 Console.WriteLine(e.Message);
        ///             }
        ///
        ///             // Check that an array of operands cannot be null
        ///             try
        ///             {
        ///                 IntegerArrayOperation.Operate(square, null);
        ///             }
        ///             catch (Exception e)
        ///             {
        ///                 Console.WriteLine();
        ///                 Console.WriteLine("Cannot apply a function to a null array:");
        ///                 Console.WriteLine(e.Message);
        ///             }
        ///         }
        ///     }
        /// }
        ///
        /// // Executing method Main() produces the following output:
        /// //
        /// // The result of squaring 2 is 4.
        /// // The result of squaring 4 is 16.
        /// // The result of squaring 8 is 64.
        /// //
        /// // Cannot apply a null function:
        /// // Value cannot be null.
        /// // Parameter name: func
        /// //
        /// // Cannot apply a function to a null array:
        /// // Value cannot be null.
        /// // Parameter name: operands
        /// </code>
        /// </para>
        /// </example>
        public static int[] Operate(Func <int, int> func, int[] operands)
        {
            if (func == null)
            {
                throw new ArgumentNullException(nameof(func));
            }
            if (operands == null)
            {
                throw new ArgumentNullException(nameof(operands));
            }

            int[] result = new int[operands.Length];
            for (int i = 0; i < result.Length; i++)
            {
                result[i] = IntegerOperation.Operate(func, operands[i]);
            }
            return(result);
        }