测试动态变量上的属性是否可用

Question

我的情况很简单.在我的代码的某处我有这个:

dynamic myVariable = GetDataThatLooksVerySimilarButNotTheSame();

//How to do this?
if (myVariable.MyProperty.Exists)   
//Do stuff

所以,基本上我的问题是如何检查(不抛出异常)我的动态变量上有某个属性可用.我可以做,GetType()但我宁愿避免,因为我真的不需要知道对象的类型.我真正想知道的是一个属性(或方法,如果让生活更轻松)是可用的.有什么指针吗？

Answer 1

我认为dynamic除非你重新实现在C#编译器中处理动态绑定的方式,否则无法确定变量是否具有某个成员而不尝试访问它.根据C#规范,这可能包括很多猜测,因为它是实现定义的.

因此,如果失败,您应该尝试访问该成员并捕获异常:

dynamic myVariable = GetDataThatLooksVerySimilarButNotTheSame();

try
{
    var x = myVariable.MyProperty;
    // do stuff with x
}
catch (RuntimeBinderException)
{
    //  MyProperty doesn't exist
} 

Answer 2

我以为我会比较Martijn的答案和svick的回答 ......

以下程序返回以下结果:

Testing with exception: 2430985 ticks
Testing with reflection: 155570 ticks

void Main()
{
    var random = new Random(Environment.TickCount);

    dynamic test = new Test();

    var sw = new Stopwatch();

    sw.Start();

    for (int i = 0; i < 100000; i++)
    {
        TestWithException(test, FlipCoin(random));
    }

    sw.Stop();

    Console.WriteLine("Testing with exception: " + sw.ElapsedTicks.ToString() + " ticks");

    sw.Restart();

    for (int i = 0; i < 100000; i++)
    {
        TestWithReflection(test, FlipCoin(random));
    }

    sw.Stop();

    Console.WriteLine("Testing with reflection: " + sw.ElapsedTicks.ToString() + " ticks");
}

class Test
{
    public bool Exists { get { return true; } }
}

bool FlipCoin(Random random)
{
    return random.Next(2) == 0;
}

bool TestWithException(dynamic d, bool useExisting)
{
    try
    {
        bool result = useExisting ? d.Exists : d.DoesntExist;
        return true;
    }
    catch (Exception)
    {
        return false;
    }
}

bool TestWithReflection(dynamic d, bool useExisting)
{
    Type type = d.GetType();

    return type.GetProperties().Any(p => p.Name.Equals(useExisting ? "Exists" : "DoesntExist"));
}

结果我建议使用反射.见下文.

回应布兰德的评论:

比率是reflection:exception100000次迭代的刻度:

Fails 1/1: - 1:43 ticks
Fails 1/2: - 1:22 ticks
Fails 1/3: - 1:14 ticks
Fails 1/5: - 1:9 ticks
Fails 1/7: - 1:7 ticks
Fails 1/13: - 1:4 ticks
Fails 1/17: - 1:3 ticks
Fails 1/23: - 1:2 ticks
...
Fails 1/43: - 1:2 ticks
Fails 1/47: - 1:1 ticks

......足够公平 - 如果你预计它会以小于〜/ 47的概率失败,那就去寻求例外.

以上假设您GetProperties()每次都在运行.您可以通过缓存GetProperties()字典或类似内容中每种类型的结果来加速该过程.如果您反复检查同一组类型,这可能会有所帮助.

Answer 3

也许用反射？

dynamic myVar = GetDataThatLooksVerySimilarButNotTheSame();
Type typeOfDynamic = myVar.GetType();
bool exist = typeOfDynamic.GetProperties().Where(p => p.Name.Equals("PropertyName")).Any(); 

Answer 4

以防万一它可以帮助某人:

如果方法GetDataThatLooksVerySimilarButNotTheSame()返回a,ExpandoObject您也可以IDictionary在检查之前强制转换为a .

dynamic test = new System.Dynamic.ExpandoObject();
test.foo = "bar";

if (((IDictionary<string, object>)test).ContainsKey("foo"))
{
    Console.WriteLine(test.foo);
}

Answer 5

对此的两个常见解决方案包括进行调用和捕获RuntimeBinderException,使用反射来检查调用,或序列化为文本格式并从那里解析.异常的问题是它们非常慢,因为构造一个时,当前的调用堆栈是序列化的.序列化为JSON或类似的东西会产生类似的惩罚.这给我们留下了反射,但它只有在底层对象实际上是一个真实成员的POCO时才有效.如果它是围绕字典,COM对象或外部Web服务的动态包装器,那么反射将无济于事.

另一个解决方案是使用它DynamicMetaObject来获取成员名称,因为DLR会看到它们.在下面的示例中,我使用静态类(Dynamic)来测试Age字段并显示它.

class Program
{
    static void Main()
    {
        dynamic x = new ExpandoObject();

        x.Name = "Damian Powell";
        x.Age = "21 (probably)";

        if (Dynamic.HasMember(x, "Age"))
        {
            Console.WriteLine("Age={0}", x.Age);
        }
    }
}

public static class Dynamic
{
    public static bool HasMember(object dynObj, string memberName)
    {
        return GetMemberNames(dynObj).Contains(memberName);
    }

    public static IEnumerable<string> GetMemberNames(object dynObj)
    {
        var metaObjProvider = dynObj as IDynamicMetaObjectProvider;

        if (null == metaObjProvider) throw new InvalidOperationException(
            "The supplied object must be a dynamic object " +
            "(i.e. it must implement IDynamicMetaObjectProvider)"
        );

        var metaObj = metaObjProvider.GetMetaObject(
            Expression.Constant(metaObjProvider)
        );

        var memberNames = metaObj.GetDynamicMemberNames();

        return memberNames;
    }
}

Answer 6

Denis的回答让我想到了使用JsonObjects的另一个解决方案,

标题属性检查器:

Predicate<object> hasHeader = jsonObject =>
                                 ((JObject)jsonObject).OfType<JProperty>()
                                     .Any(prop => prop.Name == "header");

或者更好:

Predicate<object> hasHeader = jsonObject =>
                                 ((JObject)jsonObject).Property("header") != null;

例如:

dynamic json = JsonConvert.DeserializeObject(data);
string header = hasHeader(json) ? json.header : null;

Answer 7

好吧,我遇到了类似的问题,但在单元测试中.

使用SharpTestsEx,您可以检查属性是否存在.我使用这个测试我的控制器,因为由于JSON对象是动态的,有人可以更改名称而忘记在javascript或其他东西中更改它,因此在编写控制器时测试所有属性应该会增加我的安全性.

例:

dynamic testedObject = new ExpandoObject();
testedObject.MyName = "I am a testing object";

现在,使用SharTestsEx:

Executing.This(delegate {var unused = testedObject.MyName; }).Should().NotThrow();
Executing.This(delegate {var unused = testedObject.NotExistingProperty; }).Should().Throw();

使用它,我使用"Should().NotThrow()"测试所有现有属性.

它可能不在话题范围内,但可能对某人有用.