Tuple klasse für .NET 2 und 3

Beschreibung:

für alle, die die .NET 4.0 klasse auch ohne .net 4.0 verwenden möchten und bei der migration zu einem späteren zeitpunkt kompatibel beleiben möchten habe ich aus aktuellem anlass die 2er variante zusammengefasst. die anderen varianten mit mehreren parametern könnt ihr auf basis von diesem hier ohne weiteres auch noch hinzufügen und hier posten. ich brauche momentan nur die 2er variante 😉

edit: ach ja, wenn man auf das neue framework umsteigt, muss man einfach nur diesen code löschen und gut ist (solange man das eine interface ITuple engegen der summary verwendet hat).

using System.Collections;
using System.Collections.Generic;
using System.Text;

// NOTE: THIS IS A PORT OF .NET 4.0 CODE. REMOVE THIS WHEN MIGRATING TO .net 4.0 OR HIGHER 
namespace System
{
    [Serializable]
    public class Tuple<T1, T2> : IStructuralEquatable, IStructuralComparable, IComparable, ITuple
    {
        private readonly T1 m_T1;
        private readonly T2 m_T2;
        
        [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
        public Tuple(T1 t1, T2 t2)
        {
            this.m_T1 = t1;
            this.m_T2 = t2;
        }

        public override bool Equals(object obj)
        {
            return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default);
        }

        public override int GetHashCode()
        {
            return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
        }

        int IStructuralComparable.CompareTo(object other, IComparer comparer)
        {
            if (other == null)
            {
                return 1;
            }
            Tuple<T1, T2> tuple = other as Tuple<T1, T2>;
            if (tuple == null)
            {
                throw new ArgumentException("TupleIncorrectType", "other");
            }
            int num = 0;
            num = comparer.Compare(this.m_T1, tuple.m_T1);
            if (num != 0)
            {
                return num;
            }
            return comparer.Compare(this.m_T2, tuple.m_T2);
        }

        bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
        {
            if (other == null)
            {
                return false;
            }
            Tuple<T1, T2> tuple = other as Tuple<T1, T2>;
            if (tuple == null)
            {
                return false;
            }
            return (comparer.Equals(this.m_T1, tuple.m_T1) && comparer.Equals(this.m_T2, tuple.m_T2));
        }

        int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
        {
            return Tuple.CombineHashCodes(comparer.GetHashCode(this.m_T1), comparer.GetHashCode(this.m_T2));
        }

        int IComparable.CompareTo(object obj)
        {
            return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
        }

        int ITuple.GetHashCode(IEqualityComparer comparer)
        {
            return ((IStructuralEquatable)this).GetHashCode(comparer);
        }

        string ITuple.ToString(StringBuilder sb)
        {
            sb.Append(this.m_T1);
            sb.Append(", ");
            sb.Append(this.m_T2);
            sb.Append(")");
            return sb.ToString();
        }

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.Append("(");
            return ((ITuple)this).ToString(sb);
        }
        
        public T1 Item1
        {
            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
            get
            {
                return this.m_T1;
            }
        }

        public T2 Item2
        {
            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
            get
            {
                return this.m_T2;
            }
        }

        int ITuple.Size
        {
            get
            {
                return 2;
            }
        }
    }

    public static class Tuple
    {
        internal static int CombineHashCodes(int h1, int h2)
        {
            return (((h1 << 5) + h1) ^ h2);
        }
        public static Tuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2)
        {
            return new Tuple<T1, T2>(item1, item2);
        }
    }

    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
    public sealed class TargetedPatchingOptOutAttribute : Attribute
    {
        private string m_reason;
        private TargetedPatchingOptOutAttribute()
        {
        }
        public TargetedPatchingOptOutAttribute(string reason)
        {
            this.m_reason = reason;
        }
        public string Reason
        {
            get
            {
                return this.m_reason;
            }
        }
    }

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

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

    /// <summary>
    /// DO NOT USE IN CUSTOM CODE !!!!!! IN FRAMEWORK THIS INTERFACE IS INTERNAL TOO!!!!
    /// </summary>
    internal interface ITuple
    {
        int GetHashCode(IEqualityComparer comparer);
        string ToString(StringBuilder sb);
        int Size { get; }
    }
}

Schlagwörter: <Tuple>

Wer mehr als zwei Parameter braucht und doppelten Code nicht mag, sollte sich mal in Visual Studio T4 Code Generation anschauen (kein Addin nötig, ist in VS 2008 bereits enthalten!)

T4 (Text Template Transformation Toolkit) Code Generation - Best Kept Visual Studio Secret