web-dev-qa-db-ja.com

C＃で可変個引数テンプレートをシミュレートする

C＃で可変個引数テンプレート機能をシミュレートするためのよく知られた方法はありますか？

たとえば、任意のパラメーターのセットを持つラムダを受け取るメソッドを作成したいと思います。これが私が欲しいものを擬似コードで示しています：

void MyMethod<T1,T2,...,TReturn>(Fun<T1,T2, ..., TReturn> f)
{

}

ありがとうございました

c#variadic-templates
29
nakhli

C＃ジェネリックはC++テンプレートと同じではありません。 C++テンプレートはコンパイル時に拡張され、可変個引数テンプレート引数を使用して再帰的に使用できます。 C++テンプレートの拡張は実際にはチューリング完全であるため、テンプレートで実行できることには理論的に制限はありません。

C＃ジェネリックは直接コンパイルされ、実行時に使用される型の「プレースホルダー」は空になります。

任意の数の引数を取るラムダを受け入れるには、（コードジェネレーターを介して）多くのオーバーロードを生成するか、LambdaExpressionを受け入れる必要があります。

24
Anders Abel

ジェネリック型引数（メソッドまたは型のいずれか）に対するvaradicサポートはありません。たくさんのオーバーロードを追加する必要があります。

varadicのサポートは、paramsを介した配列でのみ使用できます。つまり、.

void Foo(string key, params int[] values) {...}

ひどく-ジェネリックメソッドを書くために、これらのさまざまなT*をどのように参照しますか？おそらくあなたの最善の選択肢は、Type[]または同様のものを取ることです（コンテキストに応じて）。

8
Marc Gravell

これは古い質問ですが、これらのタイプを印刷するなどの単純なものだけを実行する場合は、タプルや「動的」を使用して追加することなく、これを非常に簡単に実行できます。

private static void PrintTypes(params dynamic[] args)
{
    foreach (var arg in args)
    {
        Console.WriteLine(arg.GetType());
    }
}

static void Main(string[] args)
{
    PrintTypes(1,1.0,"hello");
    Console.ReadKey();
}

「System.Int32」、「System.Double」、「System.String」を出力します

これらのことに対して何らかのアクションを実行したい場合、私が知る限り、2つの選択肢があります。 1つは、これらの型が互換性のあるアクションを実行できることをプログラマーに信頼することです。たとえば、任意の数のパラメーターを合計するメソッドを作成する場合などです。結果をどのように受け取りたいかを示す次のようなメソッドを書くことができます。私が推測する唯一の前提条件は、これらのタイプ間で+操作が機能することです。

    private static void AddToFirst<T>(ref T first, params dynamic[] args)
    {
        foreach (var arg in args)
        {
            first += arg;
        }
    }

    static void Main(string[] args)
    {
        int x = 0;
        AddToFirst(ref x,1,1.5,2.0,3.5,2);
        Console.WriteLine(x);

        double y = 0;
        AddToFirst(ref y, 1, 1.5, 2.0, 3.5, 2);
        Console.WriteLine(y);

        Console.ReadKey();
    }

これにより、1行目の出力はintに加算されるため「9」になり、2行目は.5が丸められず、doubleとして加算されるため「10」になります。このコードの問題は、互換性のない型をリストに渡すと、型を一緒に追加できないためエラーが発生し、コンパイル時では実行時にのみそのエラーが表示されないことです。

したがって、ユースケースによっては、別のオプションがある場合があります。そのため、最初は2つの選択肢があると言いました。可能な型の選択肢を知っていると仮定すると、インターフェイスまたは抽象クラスを作成し、それらすべての型にインターフェイスを実装させることができます。たとえば、次のようになります。申し訳ありませんが、これは少しクレイジーです。そして、それはおそらく単純化することができます。

    public interface Applyable<T>
    {
        void Apply(T input);

        T GetValue();
    }

    public abstract class Convertable<T>
    {
        public dynamic value { get; set; }

        public Convertable(dynamic value)
        {
            this.value = value;
        }

        public abstract T GetConvertedValue();
    }        

    public class IntableInt : Convertable<int>, Applyable<int>
    {
        public IntableInt(int value) : base(value) {}

        public override int GetConvertedValue()
        {
            return value;
        }

        public void Apply(int input)
        {
            value += input;
        }

        public int GetValue()
        {
            return value;
        }
    }

    public class IntableDouble : Convertable<int>
    {
        public IntableDouble(double value) : base(value) {}

        public override int GetConvertedValue()
        {
            return (int) value;
        }
    }

    public class IntableString : Convertable<int>
    {
        public IntableString(string value) : base(value) {}

        public override int GetConvertedValue()
        {
            // If it can't be parsed return zero
            int result;
            return int.TryParse(value, out result) ? result : 0;
        }
    }

    private static void ApplyToFirst<TResult>(ref Applyable<TResult> first, params Convertable<TResult>[] args)
    {
        foreach (var arg in args)
        {                
            first.Apply(arg.GetConvertedValue());  
        }
    }

    static void Main(string[] args)
    {
        Applyable<int> result = new IntableInt(0);
        IntableInt myInt = new IntableInt(1);
        IntableDouble myDouble1 = new IntableDouble(1.5);
        IntableDouble myDouble2 = new IntableDouble(2.0);
        IntableDouble myDouble3 = new IntableDouble(3.5);
        IntableString myString = new IntableString("2");

        ApplyToFirst(ref result, myInt, myDouble1, myDouble2, myDouble3, myString);

        Console.WriteLine(result.GetValue());

        Console.ReadKey();
    }

元のIntコードと同じ「9」を出力しますが、パラメーターとして実際に渡すことができる値は、実際に定義したものだけであり、機能し、エラーが発生しないことがわかっている点が異なります。もちろん、10の2番目の結果を再作成するには、DoubleableInt、DoubleableStringなどの新しいクラスを作成する必要があります。ただし、これは単なる例であるため、追加しようとはしません。あなたが書いているコードに応じて、あなたはあなたに最高のサービスを提供した実装から始めるでしょう。

うまくいけば、誰かが私がここに書いたことを改善するか、それを使用してこれがC＃でどのように行われるかを確認できます。

6
Robert Noack

上記以外の別の方法は、Tuple <、>とリフレクションを使用することです。次に例を示します。

class PrintVariadic<T>
{
    public T Value { get; set; }

    public void Print()
    {
        InnerPrint(Value);
    }

    static void InnerPrint<Tn>(Tn t)
    {
        var type = t.GetType();
        if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Tuple<,>))
        {
            var i1 = type.GetProperty("Item1").GetValue(t, new object[]{});
            var i2 = type.GetProperty("Item2").GetValue(t, new object[]{ });
            InnerPrint(i1);
            InnerPrint(i2);
            return;
        }
        Console.WriteLine(t.GetType());
    }
}

class Program
{
    static void Main(string[] args)
    {
        var v = new PrintVariadic<Tuple<
            int, Tuple<
            string, Tuple<
            double, 
            long>>>>();
        v.Value = Tuple.Create(
            1, Tuple.Create(
            "s", Tuple.Create(
            4.0, 
            4L)));
        v.Print();
        Console.ReadKey();
    }
}
4
ebf

このパターンの名前があるかどうかは必ずしもわかりませんが、返される型は渡されたすべての値の型情報を保持し、無制限の量の値を渡すことができる再帰的なジェネリックインターフェイスの次の定式化に到達しました。

public interface ITraversalRoot<TRoot>
{
    ITraversalSpecification<TRoot> Specify();
}

public interface ITraverser<TRoot, TCurrent>: ITraversalRoot<TRoot>
{
    IDerivedTraverser<TRoot, TInclude, TCurrent, ITraverser<TRoot, TCurrent>> AndInclude<TInclude>(Expression<Func<TCurrent, TInclude>> path);
}

public interface IDerivedTraverser<TRoot, TDerived, TParent, out TParentTraverser> : ITraverser<TRoot, TParent>
{
    IDerivedTraverser<TRoot, TInclude, TDerived, IDerivedTraverser<TRoot, TDerived, TParent, TParentTraverser>> FromWhichInclude<TInclude>(Expression<Func<TDerived, TInclude>> path);

    TParentTraverser ThenBackToParent();
}

ここに関係する型システムのキャストや「不正行為」はありません。より多くの値を積み重ね続けることができ、推定される戻り値の型はより多くの情報を格納し続けます。使用法は次のようになります。

var spec = Traversal
    .StartFrom<VirtualMachine>()             // ITraverser<VirtualMachine, VirtualMachine>
    .AndInclude(vm => vm.EnvironmentBrowser) // IDerivedTraverser<VirtualMachine, EnvironmentBrowser, VirtualMachine, ITraverser<VirtualMachine, VirtualMachine>>
    .AndInclude(vm => vm.Datastore)          // IDerivedTraverser<VirtualMachine, Datastore, VirtualMachine, ITraverser<VirtualMachine, VirtualMachine>>
    .FromWhichInclude(ds => ds.Browser)      // IDerivedTraverser<VirtualMachine, HostDatastoreBrowser, Datastore, IDerivedTraverser<VirtualMachine, Datastore, VirtualMachine, ITraverser<VirtualMachine, VirtualMachine>>>
    .FromWhichInclude(br => br.Mountpoints)  // IDerivedTraverser<VirtualMachine, Mountpoint, HostDatastoreBrowser, IDerivedTraverser<VirtualMachine, HostDatastoreBrowser, Datastore, IDerivedTraverser<VirtualMachine, Datastore, VirtualMachine, ITraverser<VirtualMachine, VirtualMachine>>>>
    .Specify();                              // ITraversalSpecification<VirtualMachine>

ご覧のとおり、数回の連鎖呼び出しの後、型シグネチャは基本的に読み取れなくなりますが、型推論が機能し、ユーザーに正しい型を提案する限り、これは問題ありません。

私の例では、Funcs引数を扱っていますが、おそらくこのコードを任意の型の引数を扱うように適合させることができます。

3
Asad Saeeduddin

シミュレーションの場合、次のように言うことができます。

void MyMethod<TSource, TResult>(Func<TSource, TResult> f) where TSource : Tparams {

ここで、Tparamsは可変個引数引数実装クラスです。ただし、フレームワークはそれを行うためのすぐに使えるものを提供していません。Action、Func、Tupleなどはすべて署名の長さが制限されています。私が考えることができる唯一のことは、誰かがブログを書いているのを見つけられない方法でCRTPを適用することです。これが私の実装です：

*：Tuple<T1, ..., T7, TRest>も再帰的に機能することを言及してくれた@SLaksに感謝します。クラス定義ではなく、コンストラクターとファクトリメソッドで再帰的であることに気づきました。および ランタイム型チェックを実行 型TRestの最後の引数はITupleInternalである必要があります。これは少し違った働きをします。

  • コード

    using System;

namespace VariadicGenerics {
    public interface INode {
        INode Next {
            get;
        }
    }

    public interface INode<R>:INode {
        R Value {
            get; set;
        }
    }

    public abstract class Tparams {
        public static C<TValue> V<TValue>(TValue x) {
            return new T<TValue>(x);
        }
    }

    public class T<P>:C<P> {
        public T(P x) : base(x) {
        }
    }

    public abstract class C<R>:Tparams, INode<R> {
        public class T<P>:C<T<P>>, INode<P> {
            public T(C<R> node, P x) {
                if(node is R) {
                    Next=(R)(node as object);
                }
                else {
                    Next=(node as INode<R>).Value;
                }

                Value=x;
            }

            public T() {
                if(Extensions.TypeIs(typeof(R), typeof(C<>.T<>))) {
                    Next=(R)Activator.CreateInstance(typeof(R));
                }
            }

            public R Next {
                private set;
                get;
            }

            public P Value {
                get; set;
            }

            INode INode.Next {
                get {
                    return this.Next as INode;
                }
            }
        }

        public new T<TValue> V<TValue>(TValue x) {
            return new T<TValue>(this, x);
        }

        public int GetLength() {
            return m_expandedArguments.Length;
        }

        public C(R x) {
            (this as INode<R>).Value=x;
        }

        C() {
        }

        static C() {
            m_expandedArguments=Extensions.GetExpandedGenericArguments(typeof(R));
        }

        // demonstration of non-recursive traversal
        public INode this[int index] {
            get {
                var count = m_expandedArguments.Length;

                for(INode node = this; null!=node; node=node.Next) {
                    if(--count==index) {
                        return node;
                    }
                }

                throw new ArgumentOutOfRangeException("index");
            }
        }

        R INode<R>.Value {
            get; set;
        }

        INode INode.Next {
            get {
                return null;
            }
        }

        static readonly Type[] m_expandedArguments;
    }
}

の宣言で継承されたクラスC<>のtypeパラメータに注意してください

public class T<P>:C<T<P>>, INode<P> {

はT<P>であり、クラスT<P>はネストされているため、次のようなクレイジーなことができます。

  • テスト

    [Microsoft.VisualStudio.TestTools.UnitTesting.TestClass]
public class TestClass {
    void MyMethod<TSource, TResult>(Func<TSource, TResult> f) where TSource : Tparams {
        T<byte>.T<char>.T<uint>.T<long>.
        T<byte>.T<char>.T<long>.T<uint>.
        T<byte>.T<long>.T<char>.T<uint>.
        T<long>.T<byte>.T<char>.T<uint>.
        T<long>.T<byte>.T<uint>.T<char>.
        T<byte>.T<long>.T<uint>.T<char>.
        T<byte>.T<uint>.T<long>.T<char>.
        T<byte>.T<uint>.T<char>.T<long>.
        T<uint>.T<byte>.T<char>.T<long>.
        T<uint>.T<byte>.T<long>.T<char>.
        T<uint>.T<long>.T<byte>.T<char>.
        T<long>.T<uint>.T<byte>.T<char>.
        T<long>.T<uint>.T<char>.T<byte>.
        T<uint>.T<long>.T<char>.T<byte>.
        T<uint>.T<char>.T<long>.T<byte>.
        T<uint>.T<char>.T<byte>.T<long>.
        T<char>.T<uint>.T<byte>.T<long>.
        T<char>.T<uint>.T<long>.T<byte>.
        T<char>.T<long>.T<uint>.T<byte>.
        T<long>.T<char>.T<uint>.T<byte>.
        T<long>.T<char>.T<byte>.T<uint>.
        T<char>.T<long>.T<byte>.T<uint>.
        T<char>.T<byte>.T<long>.T<uint>.
        T<char>.T<byte>.T<uint>.T<long>
        crazy = Tparams
            // trying to change any value to not match the 
            // declaring type makes the compilation fail 
            .V((byte)1).V('2').V(4u).V(8L)
            .V((byte)1).V('2').V(8L).V(4u)
            .V((byte)1).V(8L).V('2').V(4u)
            .V(8L).V((byte)1).V('2').V(4u)
            .V(8L).V((byte)1).V(4u).V('2')
            .V((byte)1).V(8L).V(4u).V('2')
            .V((byte)1).V(4u).V(8L).V('2')
            .V((byte)1).V(4u).V('2').V(8L)
            .V(4u).V((byte)1).V('2').V(8L)
            .V(4u).V((byte)1).V(8L).V('2')
            .V(4u).V(8L).V((byte)1).V('2')
            .V(8L).V(4u).V((byte)1).V('2')
            .V(8L).V(4u).V('9').V((byte)1)
            .V(4u).V(8L).V('2').V((byte)1)
            .V(4u).V('2').V(8L).V((byte)1)
            .V(4u).V('2').V((byte)1).V(8L)
            .V('2').V(4u).V((byte)1).V(8L)
            .V('2').V(4u).V(8L).V((byte)1)
            .V('2').V(8L).V(4u).V((byte)1)
            .V(8L).V('2').V(4u).V((byte)1)
            .V(8L).V('2').V((byte)1).V(4u)
            .V('2').V(8L).V((byte)1).V(4u)
            .V('2').V((byte)1).V(8L).V(4u)
            .V('7').V((byte)1).V(4u).V(8L);

        var args = crazy as TSource;

        if(null!=args) {
            f(args);
        }
    }

    [TestMethod]
    public void TestMethod() {
        Func<
            T<byte>.T<char>.T<uint>.T<long>.
            T<byte>.T<char>.T<long>.T<uint>.
            T<byte>.T<long>.T<char>.T<uint>.
            T<long>.T<byte>.T<char>.T<uint>.
            T<long>.T<byte>.T<uint>.T<char>.
            T<byte>.T<long>.T<uint>.T<char>.
            T<byte>.T<uint>.T<long>.T<char>.
            T<byte>.T<uint>.T<char>.T<long>.
            T<uint>.T<byte>.T<char>.T<long>.
            T<uint>.T<byte>.T<long>.T<char>.
            T<uint>.T<long>.T<byte>.T<char>.
            T<long>.T<uint>.T<byte>.T<char>.
            T<long>.T<uint>.T<char>.T<byte>.
            T<uint>.T<long>.T<char>.T<byte>.
            T<uint>.T<char>.T<long>.T<byte>.
            T<uint>.T<char>.T<byte>.T<long>.
            T<char>.T<uint>.T<byte>.T<long>.
            T<char>.T<uint>.T<long>.T<byte>.
            T<char>.T<long>.T<uint>.T<byte>.
            T<long>.T<char>.T<uint>.T<byte>.
            T<long>.T<char>.T<byte>.T<uint>.
            T<char>.T<long>.T<byte>.T<uint>.
            T<char>.T<byte>.T<long>.T<uint>.
            T<char>.T<byte>.T<uint>.T<long>, String>
        f = args => {
            Debug.WriteLine(String.Format("Length={0}", args.GetLength()));

            // print fourth value from the last
            Debug.WriteLine(String.Format("value={0}", args.Next.Next.Next.Value));

            args.Next.Next.Next.Value='x';
            Debug.WriteLine(String.Format("value={0}", args.Next.Next.Next.Value));

            return "test";
        };

        MyMethod(f);
    }
}

もう1つの注意点は、Tという名前の2つのクラス、ネストされていないTがあることです。

public class T<P>:C<P> {

使用法の一貫性のためだけであり、クラスCを抽象化して、直接newedされないようにしました。

上記のCodeの部分では、ジェネリック引数を展開して長さを計算する必要があります。使用した2つの拡張メソッドを次に示します。

  • コード（拡張子）

    using System.Diagnostics;
using System;

namespace VariadicGenerics {
    [DebuggerStepThrough]
    public static class Extensions {
        public static readonly Type VariadicType = typeof(C<>.T<>);

        public static bool TypeIs(this Type x, Type d) {
            if(null==d) {
                return false;
            }

            for(var c = x; null!=c; c=c.BaseType) {
                var a = c.GetInterfaces();

                for(var i = a.Length; i-->=0;) {
                    var t = i<0 ? c : a[i];

                    if(t==d||t.IsGenericType&&t.GetGenericTypeDefinition()==d) {
                        return true;
                    }
                }
            }

            return false;
        }

        public static Type[] GetExpandedGenericArguments(this Type t) {
            var expanded = new Type[] { };

            for(var skip = 1; t.TypeIs(VariadicType) ? true : skip-->0;) {
                var args = skip>0 ? t.GetGenericArguments() : new[] { t };

                if(args.Length>0) {
                    var length = args.Length-skip;
                    var temp = new Type[length+expanded.Length];
                    Array.Copy(args, skip, temp, 0, length);
                    Array.Copy(expanded, 0, temp, length, expanded.Length);
                    expanded=temp;
                    t=args[0];
                }
            }

            return expanded;
        }
    }
}

この実装では、コンパイル時の型チェックを中断しないことを選択したため、値を提供するためのparams object[]のようなシグネチャを持つコンストラクターまたはファクトリはありません。代わりに、メソッドVの流暢なパターンを使用して、マスオブジェクトのインスタンス化を行い、型を可能な限り静的に型チェックできるようにします。

1
Ken Kin