c# 中的泛型 & 访问 T 的静态成员-解网

问：

我的问题涉及 c# 以及如何访问静态成员......好吧，我真的不知道如何解释它（哪种对问题不利，不是吗？我只给你一些示例代码：

Class test<T>{
     int method1(Obj Parameter1){
         //in here I want to do something which I would explain as
         T.TryParse(Parameter1);

         //my problem is that it does not work ... I get an error.
         //just to explain: if I declare test<int> (with type Integer)
         //I want my sample code to call int.TryParse(). If it were String
         //it should have been String.TryParse()
     }
}

所以谢谢你们的回答（顺便说一句，问题是：我如何在不出错的情况下解决这个问题）。这对你来说可能是一个很简单的问题！

编辑：谢谢大家的回答！

虽然我认为 try - 流行语是最优雅的，但从我对 vb 的经验中我知道它真的很糟糕。我用过一次，运行一个程序大约需要 30 分钟，后来只花了 2 分钟来计算，只是因为我避免了尝试 - 捕捉。

这就是为什么我选择switch语句作为最佳答案的原因。它使代码更加复杂，但另一方面，我认为它相对较快且相对易于阅读。（虽然我仍然认为应该有一种更优雅的方式......也许我学的下一种语言）

不过，如果您还有其他建议，我仍在等待（并愿意参与）

C# 泛型静态方法数据访问

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
         }
     }
}

不幸的是，您无法检查 TryParse 模式，因为它是静态的 - 不幸的是，这意味着它不是特别适合泛型。

1赞 Dan Herbert 8/21/2008 #7

要完全执行您要查找的操作，唯一的方法是使用反射来检查 T 是否存在该方法。

另一个选项是通过将类型限制为 IConvertible（所有基元类型实现 IConvertible）来确保发送的对象是可转换对象。这将允许您非常灵活地将参数转换为给定类型。

Class test<T>
{
    int method1(IConvertible Parameter1){

        IFormatProvider provider = System.Globalization.CultureInfo.CurrentCulture.GetFormat(typeof(T));

        T temp = Parameter1.ToType(typeof(T), provider);
    }
}

您也可以像最初一样使用“object”类型来对此进行更改。

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

        if(Parameter1 is IConvertible) {

            IFormatProvider provider = System.Globalization.CultureInfo.CurrentCulture.GetFormat(typeof(T));

            T temp = Parameter1.ToType(typeof(T), provider);

        } else {
           // Do something else
        }
    }
}

3赞 Weeble 8/21/2008 #8

简短的回答，你不能。

长答案，你可以作弊：

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();
    }
}

我制作了一个静态字典，其中包含我可能想要使用的每种类型的 TryParse 方法的委托。然后，我编写了一个通用方法来查找字典并将调用传递给相应的委托。由于每个委托都有不同的类型，因此我只是将它们存储为对象引用，并在检索它们时将它们转换回相应的泛型类型。请注意，为了一个简单的例子，我省略了错误检查，例如检查字典中是否有给定类型的条目。

1赞 niklasfi 8/21/2008 #9

好的，伙计们：谢谢你们的鱼。现在，有了你的答案和我的研究（特别是关于将泛型类型限制为基元的文章），我将向你展示我的解决方案。

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();
    }
}

2赞 Timbo 8/21/2008 #10

还有一种方法，这次是混合中的一些反思：

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;
    }
}

下一步将尝试实现

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

具有全参数类型匹配等功能。

c# 中的泛型 & 访问 T 的静态成员

Generics in c# & accessing the static members of T

评论

评论

c# 中的泛型 &amp; 访问 T 的静态成员

Generics in c# & accessing the static members of T

评论

评论

c# 中的泛型 & 访问 T 的静态成员