// 형변환이나 런타임에 테스트 수행
public static bool AreEqual<T>(T left, T right)
{
    if (left == null)
        return right == null;
    if (left is IComparable<T>)
    {
        IComparable<T> lval = left as IComparable<T>;
        if (right is IComparable<T>)
            return lval.CompareTo(right) == 0;
        else
            throw new ArgumentException("Type does not implement IComparable<T>", nameof(right));
    }
    else // 실패
    {
        throw new ArgumentException("Type does not implement IComparable<T>", nameof(left));
    }
}

// 제약 조건 (컴파일 단계에서도 알 수 있음)
public static bool AreEqual2<T>(T left, T right)
    where T : IComparable<T> => left.CompareTo(right) == 0;

public sealed class ReverseEnumerable<T> : IEnumerable<T>
{
    private IEnumerable<T> srcSequence;
    private IList<T> originalSequence;
    
    public ReverseEnumerable(IEnumerable<T> sequence)
    {
        srcSequence = sequence;
    }
    
    // IEnumerable의 인터페이스
    public IEnumerator<T> GetEnumerator()
    {
        if(originalSequence == null)
        {
            originalSequence = new List<T>();
            foreach (T item in srcSequence)
                originalSequence.Add(item);
        }

        return new ReverseEnumerator(originalSequence);
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => this.GetEnumerator();

    private class ReverseEnumerator : IEnumerator<T>
    {
        int currentIdx;
        IList<T> collection;

        public ReverseEnumerator(IList<T> srcCollection)
        {
            collection = srcCollection;
            currentIdx = collection.Count;
        }

        public T Current => collection[currentIdx];

        object System.Collections.IEnumerator.Current => this.Current;

        // IEnumerator<T>와 IDisposable 인터페이스를 구현한다.
        public void Dispose() { }
        public bool MoveNext() => --currentIdx >= 0;
        public void Reset() => currentIdx = collection.Count;
    }
}

public ReverseEnumerable(IEnumerable<T> sequence)
{
    srcSequence = sequence;

    // 타입을 확인하여 가능하면 컬렉션을 가져다 사용할 수 있을 것이다.
    originalSequence = sequence as IList<T>;
}

// 이미 List<T>로 확인된 타입은 타입을 확인할 필요가 없다.
public ReverseEnumerable(List<T> sequence)
{
    srcSequence = sequence;
    originalSequence = sequence;
}

// IComparable<T>와 IComparable 모두 구현
public struct Customer : IComparable<Customer>, IComparable
{
    private readonly string name;

    // IComparable<Customer> 멤버
    public int CompareTo(Customer other) => name.CompareTo(other.name);

    // IComparable 멤버
    int IComparable.CompareTo(object obj)
    {
        if (!(obj is Customer))
            throw new ArgumentException("Argument is not a Customer", "obj");

        Customer other = (Customer)obj;

        return this.CompareTo(other);
    }
}

public static bool operator <(Customer left, Customer right) => left.CompareTo(right) < 0;
public static bool operator >(Customer left, Customer right) => left.CompareTo(right) > 0;
public static bool operator <=(Customer left, Customer right) => left.CompareTo(right) <= 0;
public static bool operator >=(Customer left, Customer right) => left.CompareTo(right) >= 0;

public class EngineDriverOne<T> where T : IEngine, new()
{
    public void GetThingsDone()
    {
        T driver = new T();
        using (driver as IDisposable)
        {
            driver.DoWork();
        }
    }
}

public class Base {}
public class Derived : Base {}

IEnumerable<Derived> d = new List<Derived>();
IEnumerable<Base> b = d;  // 문제 없음

Action<Base> b = (target) => { Console.WriteLine(target.GetType().Name); };
Action<Derived> d = b;
d(new Derived());  // Action<Derived> d에 Action<Base> 타입 인스턴스 b를 대입

public class Point
{
    public double X { get; }
    public double Y { get; }
    public Point(double x, double y)
    {
        this.X = x;
        this.Y = y;
    }
}

public static class Utilities
{
    // Func<T1, T2, TResult> 활용
    public static IEnumerable<TResult> Zip<T1, T2, TResult>(
        IEnumerable<T1> left, IEnumerable<T2> right, Func<T1, T2, TResult> generator)
    {
        IEnumerator<T1> leftSequence = left.GetEnumerator();
        IEnumerator<T2> rightSequence = right.GetEnumerator();

        while(leftSequence.MoveNext() && rightSequence.MoveNext())
        {
            yield return generator(leftSequence.Current, rightSequence.Current);
        }

        leftSequence.Dispose();
        rightSequence.Dispose();
    }
}

static void Main(string[] args)
{
    double[] xValues = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    double[] yValues = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

    // Delegate 전달
    List<Point> values = new List<Point>(Utilities.Zip(xValues, yValues, (x, y) => new Point(x, y)));
}

public static class Utils
{
  public static T Max<T>(T left,T right) => Comparer<T>.Default.Compare(left, right) < 0 ? right : left;
  public static T Min<T>(T left, T right) => Comparer<T>.Default.Compare(left, right) < 0 ? left : right;
}

public class Name : IComparable<Name> 
{ 
    public string First { get; set; } 
    public string Last { get; set; } 
    public string Middle { get; set; } 
    
    // IComparable<Name> 멤버 
    public int CompareTo(Name other) 
    { 
        if (Object.ReferenceEquals(this, other)) 
        { 
            return 0; 
        } 
        if (Object.ReferenceEquals(this, null)) 
        { 
            return 1; // null이 아닌 객체는 null보다 크다. 
        } 
        
        int rVal = Comparer<string>.Default.Compare(Last, other.Last); 
        if (rVal != 0) 
        {
            return rVal; 
        }
        
        rVal = Comparer<string>.Default.Compare(First, other.First); 
        if (rVal != 0) 
        {
            return rVal; 
        }
        return Comparer<string>.Default.Compare(Middle, other.Middle); 
    } 
}

public class Name : IComparable<Name>, IComparable { 
    public string First { get; set; } 
    public string Last { get; set; } 
    public string Middle { get; set; } 
    
    // IComparable<Name> 멤버 => 생략 
    public int CompareTo(Name other) { ... } 
    
    // IComparable 멤버 
    int IComparable.CompareTo(object obj) 
    { 
        if (obj.GetType() != typeof(Name)) 
        {
            throw new ArgumentException("Argument is not a Name object"); 
        }
        return this.CompareTo(obj as Name); 
    } 
}

// IFoo 인터페이스
public interface IFoo
{
    int Marker { get; set; }
}

// IFoo 의 확장 메서드
public static class FooExtenstions
{
    public static void NextMarker(this IFoo thing) =>
        thing.Marker += 1;
}

// IFoo의 구현체 MyType 클래스
public class MyType : IFoo
{
    public int Marker { get; set; }
}

// MyType 클래스에는 NextMarker() 메서드가 정의되어 있지 않지만 호출할 수 있다.
MyType t = new MyType();
t.Marker = 1;
t.NextMarker();

public static class Enumerable
{
    public static int Average(this IEnumerable<int> sequnece);
    public static int Max(this IEnumerable<int> sequence);
    public static int Min(this IEnumerable<int> sequence);
    public static int Sum(this IEnumerable<int> sequence);

    // 다른 메서드 생략
}