using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

​

namespace ConsoleApplication1

{

    class Pessoa

    {

        public RG rg;

    }

​

    class RG

    {

        public Mae mae;

    }

​

    class Mae

    {

        public string nome;

        public int idade;

    }

​

    public static class Program

    {

        static TResult? NullConditionals<TSource, TResult>(this TSource? source, Func<TSource, TResult?> selector)

            where TResult : struct

            where TSource : struct

        {

            return source == null ? (TResult?)null : selector(source.Value);

        }

​

        static TResult NullConditional<TSource, TResult>(this TSource? source, Func<TSource, TResult> selector)

            where TSource : struct

            where TResult : class

        {

            return source == null ? null : selector(source.Value);

        }

​

        static TResult? NullConditionals<TSource, TResult>(this TSource source, Func<TSource, TResult> selector)

            where TSource : class

            where TResult : struct

        {

            return source == null ? null : (TResult?) selector(source);

        }

​

        static TResult? NullConditionals<TSource, TResult>(this TSource source, Func<TSource, TResult?> selector)

            where TSource : class

            where TResult : struct

        {

            return source == null ? null : selector(source);

        }

​

        static TResult NullConditional<TSource, TResult>(this TSource source, Func<TSource, TResult> selector)

            where TSource : class

            where TResult : class

        {

            return source == null ? null : selector(source);

        }

​

​

        static TSource? AsNullable<TSource>(this TSource source)

            where TSource : struct

        {

            return (TSource?)source;

        }

​

        public static void Main(string[] args)

        {

            MainFlatten();

            return;

​

            Func<int, int> f = Fac;

​

            Func<int, int> f2 = f.Memoize();

​

            var a = f2(3);

​

            var b = f2(3);

​

            var i = new Pessoa()

                .NullConditional(x => x.rg)

                .NullConditional(x => x.mae)

                .NullConditionals(x => x.idade) ?? 50;

​

            Console.WriteLine(i);

            Console.Read();

        }

​

        public static void MainFlatten()

        {

            var list = new List<object>()

            {

                1,

                2,

                new List<object>()

                {

                    3,

                    new List<object>()

                    {

                        4,

                        "leandro"

                    },

                    5,

                    true,

                },

                6

            };

​

            Console.WriteLine(string.Join(", ", list.Flatten()));

            Console.WriteLine(string.Join(", ", list.Flatten2().Take(4)));

       //   Console.Read();

​

        }

​

        static IEnumerable<object> Flatten(this IEnumerable source)

        {

            foreach (var e in source)

            {

                if (e is IEnumerable)

                {

                    foreach (var i in Flatten((IEnumerable)e))

                    {

                        yield return i;

                    }

                }

                else

                {

                    yield return e;

                }

            }

        }

​

        static IEnumerable<object> Flatten2(this IEnumerable source)

        {

            var e = source.GetEnumerator();

            var stack = new Stack<IEnumerator>();

            var next = false;

​

            stack.Push(e);

​

            try

            {

                while (stack.Any())

                {

                    e = stack.Pop();

​

                    while ((next = e.MoveNext()))

                    {

                        if (e.Current is IEnumerable)

                        {

                            stack.Push(e);

                            stack.Push(((IEnumerable)e.Current).GetEnumerator());

                            break;

                        }

                        else

                        {

                            yield return e.Current;

                        }

                    }

​

                    if (!next)

                    {

                        var d = (e as IDisposable);

                        if (d != null) d.Dispose();

                    }

                }

            }

            finally

            {

                foreach (var x in stack.Concat(new[] { e }).OfType<IDisposable>())

                {

                    x.Dispose();

                }

            }

        }

​

        static int Fac(int x)

        {

            return (int) Math.Pow(x, 3);

        }

​

        static Func<T1, TResult> Memoize<T1, TResult>(this Func<T1, TResult> function)

        {

            var dic = Enumerable.Repeat(new { _result = default(TResult), _insertedAt = default(DateTime) } , 0).ToDictionary(x => new { _arg1 = default(T1) });

​

            return arg1 =>

            {

                var value = new { _result = default(TResult), _insertedAt = default(DateTime) };

​

                var key = new { _arg1 = arg1 };

​

                if (!dic.TryGetValue(key, out value))

                {

                    return (dic[key] = new { _result = function(arg1), _insertedAt = DateTime.Now })._result;

                }

​

                return value._result;

            };

        }

​

​

​

​

    }

}

​