C# 中的泛型和访问 T 的静态成员
-
09-06-2019 - |
题
我的问题涉及 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 - catch 短语是最优雅的,但根据我使用 vb 的经验,我知道它确实很糟糕。我用过一次,运行一个程序花了大约30分钟,后来只花了2分钟计算,只是因为我避免了try-catch。
这就是为什么我选择 swich 语句作为最佳答案。它使代码更加复杂,但另一方面我认为它相对较快且相对易于阅读。(虽然我仍然认为应该有一个更优雅的方式......也许用我学习的下一种语言:P)
不过,如果您有其他建议,我仍在等待(并愿意参与)
解决方案
还有一种方法可以做到这一点,这次是在混合中进行一些反思:
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 );
具有完整的参数类型匹配等。
其他提示
问题是 TryParse 没有在任何地方的接口或基类上定义,因此您不能假设传递到您的类中的类型将具有该功能。除非你能以某种方式限制 T,否则你会经常遇到这种情况。
简短的回答,你不能。
长答案,你可以作弊:
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 方法的委托。然后,我编写了一个通用方法来查找字典并将调用传递给适当的委托。由于每个委托都有不同的类型,因此我只是将它们存储为对象引用,并在检索它们时将它们转换回适当的泛型类型。请注意,为了一个简单的示例,我省略了错误检查,例如检查字典中是否有给定类型的条目。
要访问特定类或接口的成员,您需要使用Where关键字并指定具有该方法的接口或基类。
在上面的实例中,TryParse 不是来自接口或基类,因此您在上面尝试执行的操作是不可能的。最好只使用 Convert.ChangeType 和 try/catch 语句。
class test<T>
{
T Method(object P)
{
try {
return (T)Convert.ChangeType(P, typeof(T));
} catch(Exception e) {
return null;
}
}
}
你的意思是做这样的事情:
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 模式,因为它是静态的 - 不幸的是,这意味着它不是特别适合泛型。
准确执行您要查找的操作的唯一方法是使用反射来检查 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);
}
}
您还可以通过使用“对象”类型来对此进行变体,而不是像原来那样。
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
}
}
}
好了朋友们:谢谢大家的鱼。现在有了你的答案和我的研究(特别是关于 将泛型类型限制为基元)我将向您展示我的解决方案。
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();
}
}
这并不是真正的解决方案,但在某些情况下它可能是一个不错的选择:我们可以将额外的委托传递给通用方法。
为了澄清我的意思,让我们举一个例子。假设我们有一些通用工厂方法,它应该创建 T 的实例,然后我们希望它调用另一个方法,以进行通知或额外的初始化。
考虑以下简单的类:
public class Example
{
// ...
public static void PostInitCallback(Example example)
{
// Do something with the object...
}
}
以及以下静态方法:
public static T CreateAndInit<T>() where T : new()
{
var t = new T();
// Some initialization code...
return t;
}
所以现在我们必须这样做:
var example = CreateAndInit<Example>();
Example.PostInitCallback(example);
然而,我们可以改变我们的方法来接受额外的委托:
public delegate void PostInitCallback<T>(T t);
public static T CreateAndInit<T>(PostInitCallback<T> callback) where T : new()
{
var t = new T();
// Some initialization code...
callback(t);
return t;
}
现在我们可以将调用更改为:
var example = CreateAndInit<Example>(Example.PostInitCallback);
显然这仅在非常特定的场景中有用。但这是最干净的解决方案,因为我们获得了编译时安全性,不涉及“黑客”,并且代码非常简单。
你可能做不到。
首先,如果可能的话,您需要对 T 进行更严格的限制,以便类型检查器可以确保 T 的所有可能替换实际上都有一个名为 TryParse 的静态方法。
您可能想阅读我之前的帖子 将泛型类型限制为基元. 。这可能会给您一些限制可以传递给泛型的类型的指示(因为 类型解析 显然仅适用于一定数量的原语( 字符串.TryParse 显然是例外,这没有意义)。
一旦您对类型有更多的了解,您就可以尝试解析它。你可能需要一些丑陋的开关(来调用正确的 尝试解析 )但我认为你可以实现所需的功能。
如果您需要我进一步解释上述任何内容,请询问:)
最佳代码:通过这种方式将 T 限制为 ValueType:
class test1<T> where T: struct
这里的“结构”是指值类型。String 是一个类,而不是值类型。int、float、Enums 都是值类型。
顺便说一句,编译器不接受调用静态方法或访问“类型参数”上的静态成员,如下例所示,该示例将无法编译:(
class MyStatic { public static int MyValue=0; }
class Test<T> where T: MyStatic
{
public void TheTest() { T.MyValue++; }
}
=> 错误 1“T”是“类型参数”,在给定上下文中无效
SL。
这不是静力学的工作原理。您必须将静态视为全局类中的一种,即使它们分布在一大堆类型中。我的建议是使其成为 T 实例内的一个属性,可以访问必要的静态方法。
此外,T 是某个事物的实际实例,就像任何其他实例一样,您无法通过实例化值访问该类型的静态数据。以下是要执行的操作的示例:
class a {
static StaticMethod1 ()
virtual Method1 ()
}
class b : a {
override Method1 () return StaticMethod1()
}
class c : a {
override Method1 () return "XYZ"
}
class generic<T>
where T : a {
void DoSomething () T.Method1()
}