检查泛型类型的字段

发布于 2024-11-02 23:06:40 字数 213 浏览 2 评论 0原文

public static int GetResult<TType>(TType aObject) {
    if(aObject.mValue==12)
        return 99;
    return 20;
}

我如何检查 TType 的字段 mValue,我猜反射可能会出现这种情况,但我不确定如何检查?

谢谢。

public static int GetResult<TType>(TType aObject) {
    if(aObject.mValue==12)
        return 99;
    return 20;
}

How can I check the field mValue of TType, I'm guessing reflection may come into this, but I'm unsure how?

Thanks.

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(3

心清如水 2024-11-09 23:06:40

当您想要保留强类型和编译时安全性时,泛型非常有用。如果您要诉诸反射,则无需使用泛型。因此,一种方法是定义包含此属性的接口或基类:

public interface IFoo
{
    int Value { get; set; }
}

然后对该类型进行通用约束:

public static int GetResult<TType>(TType aObject) where TType: IFoo
{
    if(aObject.Value == 12)
    {
        return 99;
    }
    return 20;
}

Generics are useful when you want to preserve strong typing and compile-time safety. If you are going to resort to Reflection no need to use generics. So one way would be to define an interface or a base class containing this property:

public interface IFoo
{
    int Value { get; set; }
}

and then have a generic constraint on the type:

public static int GetResult<TType>(TType aObject) where TType: IFoo
{
    if(aObject.Value == 12)
    {
        return 99;
    }
    return 20;
}
把时间冻结 2024-11-09 23:06:40

这是我使用的模式:

首先创建一个接口:

IFoo
{
    int mValue {get; }
}

然后是一个实现该接口的“临时”类

AdHocIFoo : IFoo
{
    Func<int> get_mValue;

    public AdHocIFoo(Func<int> getValue)
    {
         this.get_mValue = getValue;
    }

    public int mValue { get { return get_mValue(); } }

}

现在,如果您有这样定义的类型,例如 Bar 和 Person:

class Bar
{
    public int Baz { get; set; }
}

class Person
{
    public int ID {get; set; }
}

那么您可以使用类似于以下的代码;

var bar = new Bar() { Baz = 3 };
var per = new Person() { ID = 43 };

var foo1 = new AdHocIFoo(x => bar.Baz);
var foo2 = new AdHocIFoo(x => per.ID);

var result1 = GetResult<AdHocIFoo>(foo1);
var result2 = GetResult<AdHocIFoo>(foo2);

Here's a pattern that I use:

First create an interface:

IFoo
{
    int mValue {get; }
}

Then an "adhoc" class that implements the interface

AdHocIFoo : IFoo
{
    Func<int> get_mValue;

    public AdHocIFoo(Func<int> getValue)
    {
         this.get_mValue = getValue;
    }

    public int mValue { get { return get_mValue(); } }

}

Now, if you have types, say, Bar and Person defined like this:

class Bar
{
    public int Baz { get; set; }
}

class Person
{
    public int ID {get; set; }
}

Then you can use code similar to the following;

var bar = new Bar() { Baz = 3 };
var per = new Person() { ID = 43 };

var foo1 = new AdHocIFoo(x => bar.Baz);
var foo2 = new AdHocIFoo(x => per.ID);

var result1 = GetResult<AdHocIFoo>(foo1);
var result2 = GetResult<AdHocIFoo>(foo2);
怎言笑 2024-11-09 23:06:40

您需要使用“where”关键字将 TType 限制为您知道具有 mValue 字段的类型或接口。

如果您不想这样做,可以使用dynamic关键字
例如,

dynamic value= aObject
if (value.mValue == 12)
    return 99;
return 20;

但这应该是最后的手段,因为如果您的对象没有 mValue,它将在运行时失败。

You'd need to restrict TType using the 'where' keyword to a type or interface which you know has a mValue field.

If you don't want to do that, you can use the dynamic keyword
e.g.

dynamic value= aObject
if (value.mValue == 12)
    return 99;
return 20;

But this should be a last resort as it will fail at runtime if your object doesn't have a mValue.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文