Generics in c# & Zugriff auf die statischen Elemente von T

Einer mehr Weg, es zu tun, diesmal auch einige Reflexion in der Mischung:

static class Parser
{
    public static bool TryParse<TType>( string str, out TType x )
    {
        //Get the type on that TryParse shall be called
        Type objType = typeof( TType );

        //Enumerate the methods of TType
        foreach( MethodInfo mi in objType.GetMethods() )
        {
            if( mi.Name == "TryParse" )
            {
                //We found a TryParse method, check for the 2-parameter-signature
                ParameterInfo[] pi = mi.GetParameters();
                if( pi.Length == 2 ) //Find TryParse( String, TType )
                {
                    //Build a parameter list for the call
                    object[] paramList = new object[2] { str, default( TType ) };

                    //Invoke the static method
                    object ret = objType.InvokeMember( "TryParse", BindingFlags.InvokeMethod, null, null, paramList );

                    //Get the output value from the parameter list
                    x = (TType)paramList[1];
                    return (bool)ret;
                }
            }
        }

        //Maybe we should throw an exception here, because we were unable to find the TryParse
        //method; this is not just a unable-to-parse error.

        x = default( TType );
        return false;
    }
}

Der nächste Schritt wäre zu versuchen,

public static TRet CallStaticMethod<TRet>( object obj, string methodName, params object[] args );

Mit voller parameter-Typ-matching usw.

Kurze Antwort, können Sie nicht.

Lange Antwort, die Sie betrügen können:

public class Example
{
    internal static class Support
    {
        private delegate bool GenericParser<T>(string s, out T o);
        private static Dictionary<Type, object> parsers =
            MakeStandardParsers();
        private static Dictionary<Type, object> MakeStandardParsers()
        {
            Dictionary<Type, object> d = new Dictionary<Type, object>();
            //You need to add an entry for every type you want to cope with.
            d[typeof(int)] = new GenericParser<int>(int.TryParse);
            d[typeof(long)] = new GenericParser<long>(long.TryParse);
            d[typeof(float)] = new GenericParser<float>(float.TryParse);
            return d;
        }
        public static bool TryParse<T>(string s, out T result)
        {
            return ((GenericParser<T>)parsers[typeof(T)])(s, out result);
        }
    }
    public class Test<T>
    {
        public static T method1(string s)
        {
            T value;
            bool success = Support.TryParse(s, out value);
            return value;
        }
    }
    public static void Main()
    {
        Console.WriteLine(Test<int>.method1("23"));
        Console.WriteLine(Test<float>.method1("23.4"));
        Console.WriteLine(Test<long>.method1("99999999999999"));
        Console.ReadLine();
    }
}

Machte ich eine statische Wörterbuch-holding Delegierter für die TryParse-Methode, die von jedem Typ, den ich verwenden könnte. Ich schrieb dann eine generische Methode zum nachschlagen das Wörterbuch auf und übergeben Sie den Anruf an die entsprechende Stellvertretung. Da jeder Delegierte hat eine andere Art, die ich nur speichern Sie Sie als Objekt-Referenzen auf und warf Sie zurück auf die entsprechenden Generika geben, wenn ich Sie wiederbekommen. Beachten Sie, dass für den Willen ein einfaches Beispiel, das ich ausgelassen habe, Fehler zu überprüfen, wie um zu prüfen, ob wir einen Eintrag in das Wörterbuch für den angegebenen Typ.

Meinst du etwas wie das hier tun:

Class test<T>
{
     T method1(object Parameter1){

         if( Parameter1 is T ) 
         {
              T value = (T) Parameter1;
             //do something with value
             return value;
         }
         else
         {
             //Parameter1 is not a T
             return default(T); //or throw exception
         }
     }
}

Leider kann man nicht überprüfen, für die TryParse-Muster, da es statisch ist - was leider bedeutet, dass es ist nicht besonders gut geeignet, um Generika.

Ok, Jungs: Danke für den Fisch. Jetzt mit Ihren Antworten und meine Forschung (vor allem die Artikel auf die Begrenzung generische Typen zu geometrieelementen) ich zeige dir meine Lösung.

Class a<T>{
    private void checkWetherTypeIsOK()
    {
        if (T is int || T is float //|| ... any other types you want to be allowed){
            return true;
        }
        else {
            throw new exception();
        }
    }
    public static a(){
        ccheckWetherTypeIsOK();
    }
}

Du wahrscheinlich nicht.

Zunächst, wenn es möglich sein sollte, müssten Sie eine festere Schranke für T, so der typechecker sicher sein konnte, dass Sie alle möglichen Substitutionen für T hatte eigentlich eine statische Methode aufgerufen, TryParse.

Besten code: beschränken Sie T ValueType diese Weise:

class test1<T> where T: struct

"Struktur" bedeutet hier einen Wert geben.
String ist eine Klasse, nicht ein Wert-Typ.
int, float, Enums sind alle Wert-Typen.

btw der compiler nicht akzeptieren Aufruf von statischen Methoden oder Zugriff auf statische member auf 'type Parameter' wie in folgendem Beispiel wird nicht kompilieren 🙁

class MyStatic { public static int MyValue=0; }
class Test<T> where T: MyStatic
{
    public void TheTest() { T.MyValue++; }
}

=> Fehler 1 'T' a "- Typ-parameter', das gilt nicht in den gegebenen Kontext

SL.