// Copyright 2004-2011 Castle Project - http://www.castleproject.org/
// 
// 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.
public class MethodSignatureComparer : IEqualityComparer<MethodInfo>
{
    public static readonly MethodSignatureComparer Instance = new MethodSignatureComparer();
    public bool Equals(MethodInfo x, MethodInfo y)
    {
        if (x == null && y == null)
        {
            return true;
        }
        if (x == null || y == null)
        {
            return false;
        }
        return EqualNames(x, y) &&
               EqualGenericParameters(x, y) &&
               EqualSignatureTypes(x.ReturnType, y.ReturnType) &&
               EqualParameters(x, y);
    }
    private bool EqualNames(MethodInfo x, MethodInfo y)
    {
        return x.Name == y.Name;
    }
    public bool EqualGenericParameters(MethodInfo x, MethodInfo y)
    {
        if (x.IsGenericMethod != y.IsGenericMethod)
        {
            return false;
        }
        if (x.IsGenericMethod)
        {
            Type[] xArgs = x.GetGenericArguments();
            Type[] yArgs = y.GetGenericArguments();
            if (xArgs.Length != yArgs.Length)
            {
                return false;
            }
            for (int i = 0; i < xArgs.Length; ++i)
            {
                if (xArgs[i].IsGenericParameter != yArgs[i].IsGenericParameter)
                {
                    return false;
                }
                if (!xArgs[i].IsGenericParameter && !xArgs[i].Equals(yArgs[i]))
                {
                    return false;
                }
            }
        }
        return true;
    }
    public bool EqualParameters(MethodInfo x, MethodInfo y)
    {
        ParameterInfo[] xArgs = x.GetParameters();
        ParameterInfo[] yArgs = y.GetParameters();
        if (xArgs.Length != yArgs.Length)
        {
            return false;
        }
        for (int i = 0; i < xArgs.Length; ++i)
        {
            if (!EqualSignatureTypes(xArgs[i].ParameterType, yArgs[i].ParameterType))
            {
                return false;
            }
        }
        return true;
    }
    public bool EqualSignatureTypes(Type x, Type y)
    {
        if (x.IsGenericParameter != y.IsGenericParameter)
        {
            return false;
        }
        if (x.IsGenericParameter)
        {
            if (x.GenericParameterPosition != y.GenericParameterPosition)
            {
                return false;
            }
        }
        else
        {
            if (!x.Equals(y))
            {
                return false;
            }
        }
        return true;
    }
    public int GetHashCode(MethodInfo obj)
    {
        return obj.Name.GetHashCode() ^ obj.GetParameters().Length; 
        // everything else would be too cumbersome
    }
}

public class GenericClass<T>
{
    public void DoSomethingGeneric(string notAGenericString)
    {
        // ...
    }
}

public class GenericProvider
{
    public GenericClass<T> ProvideSomethingGeneric<T>()
    {
        return null;
    }
    public GenericClass<T> ProvideAnotherGenericThing<T>()
    {
        return null;
    }
}

Type genericProviderType = typeof (GenericProvider);
MethodInfo provideSomethingGeneric = 
    genericProviderType.GetMethod("ProvideSomethingGeneric");
MethodInfo provideAnotherGenericThing =
    genericProviderType.GetMethod("ProvideAnotherGenericThing");
Type firstGenericType = provideSomethingGeneric.ReturnType;
Type secondGenericType = provideAnotherGenericThing.ReturnType;

if (firstGenericType.Equals(secondGenericType))
{
    // False
}

MethodInfo firstGenericTypeMethod =
    firstGenericType.GetMethod("DoSomethingGeneric");
MethodInfo secondGenericTypeMethod =
    secondGenericType.GetMethod("DoSomethingGeneric");
if (firstGenericTypeMethod.Equals(secondGenericTypeMethod))
{
    // False
}

public class ToStringComparer<T> : IEqualityComparer<T>
{
    public bool Equals(T x, T y)
    {
        return x.ToString() == y.ToString();
    }
    public int GetHashCode(T obj)
    {
        returnobj.ToString().GetHashCode();
    }
}

IEqualityComparer<MethodInfo> methodComparer = new ToStringComparer<MethodInfo>();
if (methodComparer.Equals(firstGenericTypeMethod, secondGenericTypeMethod))
{
    // True
}
IEqualityComparer<Type> typeComparer = new ToStringComparer<Type>();
if (typeComparer.Equals(firstGenericType, secondGenericType))
{
    // True
}

internal class StructuralComparer : IComparer
{
    public int Compare(object x,object y)
    {
        if (x == null)
        {
            if (y != null)
            {
                return -1;
            }
            else
            {
                return 0;
            }
        }
        else
        {
            if (y == null)
            {
                return 1;
            }
            IStructuralComparable structuralComparable = x as IStructuralComparable;
            if (structuralComparable != null)
            {
                return structuralComparable.CompareTo(y, this);
            }
            else
            {
                return Comparer.Default.Compare(x, y);
            }
        }
    }
}

public interface IStructuralComparable
{
    int CompareTo(object other, IComparer comparer);
}

public class ArrayMaxComparer : Comparer<int[]>
{
    public override int Compare(int[] x, int[] y)
    {
        int firstMax = x.Max();
        int secondMax = y.Max();
 
        if (firstMax > secondMax)
        {
            return 1;
        }
        else if (firstMax < secondMax)
        {
            return -1;
        }
        return 0;
    }
}

int[][] numbers =
    new[]
        {
            new[] {1},
            new[] {1, 2, 3},
            new[] {5, 8}
        };
int[][] otherNumbers =
    new[]
        {
            new[] {1, 3, 3, 1},
            new[] {1, 4, 6, 4, 1},
            new[] {1, 5, 10, 10, 5, 1}
        };
IStructuralComparable numbersStructuralComparable = numbers;
int result =
    numbersStructuralComparable.CompareTo(otherNumbers, new ArrayMaxComparer()); // -1

StructuralComparisons.StructuralEqualityComparer

int[] theNumbers = new int[] {4, 8, 15, 16, 23, 42};
int[] evil = new [] {4, 8, 15, 16, 23, 42};
if (StructuralComparisons.StructuralEqualityComparer.Equals(theNumbers, evil))
{
    // True
}

[Serializable]
internal class StructuralEqualityComparer : IEqualityComparer
{
    public bool Equals(object x,object y)
    {
        if (x != null)
        {
            IStructuralEquatable structuralEquatable = x as IStructuralEquatable;
            if (structuralEquatable != null)
            {
                return structuralEquatable.Equals(y, (IEqualityComparer) this);
            }
            if (y != null)
            {
                return x.Equals(y);
            }
            else
            {
                return false;
            }
        }
        else if (y != null)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    public int GetHashCode(objectobj)
    {
        if (obj == null)
        {
            return 0;
        }
        IStructuralEquatable structuralEquatable = obj as IStructuralEquatable;
        if (structuralEquatable !=null)
        {
            return structuralEquatable.GetHashCode((IEqualityComparer)this);
        }
        else
        {
            return obj.GetHashCode();
        }
    }
}

int[] theNumbers = new int[] {4, 8, 15, 16, 23, 42};
int[] evil = new int[] {4, 8, 15, 16, 23, 42};
if (theNumbers.Equals(evil))
{
    // False
}

public interface IStructuralEquatable
{
    bool Equals(object other, IEqualityComparer comparer);
    int GetHashCode(IEqualityComparer comparer);
}

public bool Equals(object other, IEqualityComparer comparer)
{
    Array otherArray = other asArray;
    if (otherArray == null)
    {
        return false;
    }
    else if (this.Length != otherArray.Length)
    {
        return false;
    }
    else
    {
        for (int i = 0; i <this.Length; i++)
        {
            if (!comparer.Equals(this[i], otherArray[i]))
            {
                return false;
            }
        }
        return true;
    }
}

public struct MyStruct : IStructuralEquatable
{
    private int mNumber;
    private string mName;
    public bool Equals(object other, IEqualityComparer comparer)
    {
        if (!(other is MyStruct))
        {
            return false;
        }
        MyStruct otherStruct = (MyStruct) other;
        
        if (!comparer.Equals(mNumber, otherStruct.mNumber))
        {
            return false;
        }
        if (!comparer.Equals(mName, otherStruct.mName))
        {
            return false;
        }
        return true;
    }
}

int[] theNumbers = new int[] { 4, 8, 15, 16, 23, 42 };
int[] evil = new int[] { 4, 8, 15, 16, 23, 42 };
IStructuralEquatable theNumbersStructuralEquatable = theNumbers;
if (theNumbersStructuralEquatable.Equals( evil,EqualityComparer<int>.Default))
{
    // True
}

string[] tokens = new string[] {"The", "quick", "brown", "fox","jumps", "over", "the", "lazy","dog"};
string[] otherTokens = new string[] { "The", "Quick", "Brown", "fox","jUmps", "ovEr", "the", "lazy","Dog" };
IStructuralEquatable tokensStructuralEquatable = tokens;
if(tokensStructuralEquatable.Equals(otherTokens, StringComparer.CurrentCultureIgnoreCase))
{
    // True
}

MD5 algorithm = MD5.Create();
using (FileStream stream = newFileStream(@"MyFile.txt",FileMode.Open))
{
    byte[] hash = algorithm.ComputeHash(stream);
}

Guid hashGuid;
MD5 algorithm = MD5.Create();
using (FileStream stream = newFileStream(@"MyFile.txt",FileMode.Open))
{
    byte[] hash = algorithm.ComputeHash(stream);
    hashGuid = new Guid(hash);
}
Console.WriteLine(hashGuid);//1245511d-d93c-9054-5eb0-04a9a5ac51c9

if (Guid.TryParse(value, out result))
{
    // ...
}

private static bool TryParse(string value, out Guid result)
{
    try
    {
        result = new Guid(value);
    }
    catch (FormatException)
    {
        result = Guid.Empty;
        return false;
    }
    return true;
}

private static readonly Regex mGuidRegex =
    new Regex
        (@"^(\{{0,1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}\}{0,1})$",
         RegexOptions.Compiled);
private static bool TryParse(string value, out Guid result)
{
    if (mGuidRegex.IsMatch(value))
    {
        result = new Guid(value);
        return true;
    }
    else
    {
        result = Guid.Empty;
        return false;
    }
}

Guid myGuid = Guid.NewGuid();
string guidAsString = myGuid.ToString(); // d8f07443-dffa-42bf-857f-2d041e60177a

Guid firstGuid =
    new Guid("{d8f07443-dffa-42bf-857f-2d041e60177a}");
Guid secondGuid =
    new Guid("d8f07443dffa42bf857f2d041e60177a");
if (firstGuid == secondGuid)
{
    // True
}

byte[] bytes = myGuid.ToByteArray();

Guid myGuid = new Guid(bytes);