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


225

我的情况很简单。在我的代码中,我有这个地方:

dynamic myVariable = GetDataThatLooksVerySimilarButNotTheSame();

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

因此,基本上我的问题是如何检查(不引发异常)动态变量上是否有某个属性可用。我可以,GetType()但是我宁愿避免这种情况,因为我真的不需要知道对象的类型。我真正想知道的只是一个属性(或方法,如果使生活更轻松)是否可用。有指针吗?


1
这里有一些建议: stackoverflow.com/questions/2985161/…-到目前为止还没有被接受的答案。
安德鲁·安德森

谢谢,我可以看到如何使fir成为解决方案之一,而我想知道是否有任何我想念的东西
轮回危机2010年

Answers:


159

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

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

dynamic myVariable = GetDataThatLooksVerySimilarButNotTheSame();

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

2
我将其标记为答案已经很久了,它似乎确实是最好的答案
轮次危机2012年


20
@ministrymason如果您打算强制转换IDictionary并与其一起使用,那仅适用于ExpandoObject,它将不适用于任何其他dynamic对象。
svick 2012年

5
RuntimeBinderExceptionMicrosoft.CSharp.RuntimeBinder名称空间中。
DavidRR

8
无论这种情况的具体细节如何,我仍然觉得通常使用try / catch而不是if / else是不好的做法。
Alexander Ryan Baggett

74

我以为我会比较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

...足够公平-如果您期望它以不到〜1/47的概率失败,那么请寻求例外。


以上假设您GetProperties()每次都在运行。您可以通过GetProperties()将字典或类似物中每种类型的结果缓存起来来加快处理速度。如果您要一遍又一遍地检查同一组类型,这可能会有所帮助。


7
我同意并喜欢在我的工作中进行反思。它比“尝试/捕获”获得的收益仅在抛出异常时发生。因此,在这里使用反射之前,有人应该问一下-这可能是某种方法吗?90%甚至75%的时间,您的代码都会通过吗?这样,“尝试/捕获”仍然是最佳的。如果悬而未决,或者最有可能选择太多,那么您的反思就在眼前。
平淡的

@bland编辑答案。
dav_i 2013年

1
谢谢,看起来真的很完整。
平淡的

@dav_i比较两者是不公平的,因为两者的行为不同。svick的答案更加完整。
nawfal 2014年

1
@dav_i不,他们不执行相同的功能。Martijn的答案检查是否在C#中的常规编译时类型上存在属性,该属性声明为动态的(意味着它忽略了编译时安全性检查)。svick的答案检查属性是否存在于真正的动态对象(即实现的对象)上IIDynamicMetaObjectProvider。我确实了解您的回答背后的动机,并对此表示赞赏。这样回答很公平。
nawfal 2014年

52

也许使用反射?

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

2
引述


12
您可以不用Where.Any(p => p.Name.Equals("PropertyName"))
-dav_i

请参阅我的答案以进行答案比较。
dav_i 2013年

3
作为一个班轮:((Type)myVar.GetType()).GetProperties().Any(x => x.Name.Equals("PropertyName"))。要使编译器对lambda满意,需要强制类型转换。
MushinNoShin 2015年

38

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

如果该方法GetDataThatLooksVerySimilarButNotTheSame()返回,ExpandoObject则还可以IDictionary在检查之前强制转换为。

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

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

3
不知道为什么这个答案没有更多的选票,因为它的确符合要求(没有异常抛出或反射)。
Wolfshead

7
@Wolfshead如果您知道动态对象是ExpandoObject或实现IDictionary <string,object>的其他对象,则此答案很好,但是如果碰巧是其他对象,则此操作将失败。
Damian Powell

9

对此的两种常见解决方案包括进行调用和捕获RuntimeBinderException,使用反射来检查调用,或者序列化为文本格式并从那里进行解析。异常的问题是它们非常慢,因为构造一个时,当前的调用堆栈会被序列化。序列化为JSON或类似方法会产生类似的损失。这使我们有了反思,但只有当基础对象实际上是上面有真实成员的POCO时,它才起作用。如果它是围绕字典,COM对象或外部Web服务的动态包装器,则反射将无济于事。

另一种解决方案是使用DynamicMetaObjectDLR看到的成员名称。在下面的示例中,我使用静态类(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;
    }
}

事实证明Dynamiteynuget包已经做到了。(nuget.org/packages/Dynamitey
达米安鲍威尔

8

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;

1
是否有机会知道这个答案出了什么问题?
Charles HETIER

不知道为什么这被否决了,对我来说很棒。我将每个属性的谓词移到一个帮助器类中,并调用了Invoke方法以从每个属性返回一个布尔值。
markp3rry 2015年

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()”测试所有现有属性。

它可能不在主题之内,但对某人可能有用。


谢谢,非常有用。使用SharpTestsEx,我还使用以下行来测试动态属性的值:((string)(testedObject.MyName)).Should().Be("I am a testing object");
Remko Jansen 2014年

2

在@karask回答之后,您可以像下面这样将函数包装为辅助函数:

public static bool HasProperty(ExpandoObject expandoObj,
                               string name)
{
    return ((IDictionary<string, object>)expandoObj).ContainsKey(name);
}

2

对我来说,这有效:

if (IsProperty(() => DynamicObject.MyProperty))
  ; // do stuff



delegate string GetValueDelegate();

private bool IsProperty(GetValueDelegate getValueMethod)
{
    try
    {
        //we're not interesting in the return value.
        //What we need to know is whether an exception occurred or not

        var v = getValueMethod();
        return v != null;
    }
    catch (RuntimeBinderException)
    {
        return false;
    }
    catch
    {
        return true;
    }
}

null并不意味着该属性不存在
quetzalcoatl 2015年

我知道,但如果是零,我不需要为我的用例做任何的价值,因此它是确定
杰斯特

0

如果您控制用作动态类型的类型,那么是否不能为每个属性访问返回一个元组而不是一个值?就像是...

public class DynamicValue<T>
{
    internal DynamicValue(T value, bool exists)
    {
         Value = value;
         Exists = exists;
    }

    T Value { get; private set; }
    bool Exists { get; private set; }
}

可能是一个幼稚的实现,但是如果您每次都在内部构造其中一个并返回它而不是实际值,则可以检查Exists每个属性访问,然后按Value是否存在值来进行检查default(T)(如果不存在)(无关紧要)。

就是说,我可能缺少有关动态工作原理的一些知识,这可能不是一个可行的建议。


0

就我而言,我需要检查是否存在具有特定名称的方法,因此我为此使用了一个接口

var plugin = this.pluginFinder.GetPluginIfInstalled<IPlugin>(pluginName) as dynamic;
if (plugin != null && plugin is ICustomPluginAction)
{
    plugin.CustomPluginAction(action);
}

同样,接口不仅可以包含方法:

接口可以包含方法,属性,事件,索引器,或这四种成员类型的任意组合。

来自:接口(C#编程指南)

优雅,无需捕捉例外或反省...


0

我知道这确实是老文章,但这是使用dynamictype in 的简单解决方案c#

  1. 可以使用简单的反射来枚举直接属性
  2. 或可以使用object扩展方法
  3. 或使用GetAsOrDefault<int>方法来获取一个新的强类型对象,如果存在则使用value,否则使用default。
public static class DynamicHelper
{
    private static void Test( )
    {
        dynamic myobj = new
                        {
                            myInt = 1,
                            myArray = new[ ]
                                      {
                                          1, 2.3
                                      },
                            myDict = new
                                     {
                                         myInt = 1
                                     }
                        };

        var myIntOrZero = myobj.GetAsOrDefault< int >( ( Func< int > )( ( ) => myobj.noExist ) );
        int? myNullableInt = GetAs< int >( myobj, ( Func< int > )( ( ) => myobj.myInt ) );

        if( default( int ) != myIntOrZero )
            Console.WriteLine( $"myInt: '{myIntOrZero}'" );

        if( default( int? ) != myNullableInt )
            Console.WriteLine( $"myInt: '{myNullableInt}'" );

        if( DoesPropertyExist( myobj, "myInt" ) )
            Console.WriteLine( $"myInt exists and it is: '{( int )myobj.myInt}'" );
    }

    public static bool DoesPropertyExist( dynamic dyn, string property )
    {
        var t = ( Type )dyn.GetType( );
        var props = t.GetProperties( );
        return props.Any( p => p.Name.Equals( property ) );
    }

    public static object GetAs< T >( dynamic obj, Func< T > lookup )
    {
        try
        {
            var val = lookup( );
            return ( T )val;
        }
        catch( RuntimeBinderException ) { }

        return null;
    }

    public static T GetAsOrDefault< T >( this object obj, Func< T > test )
    {
        try
        {
            var val = test( );
            return ( T )val;
        }
        catch( RuntimeBinderException ) { }

        return default( T );
    }
}

0

作为ExpandoObject继承,IDictionary<string, object>您可以使用以下检查

dynamic myVariable = GetDataThatLooksVerySimilarButNotTheSame();

if (((IDictionary<string, object>)myVariable).ContainsKey("MyProperty"))    
//Do stuff

您可以使一个实用程序方法来执行此检查,这将使代码更加清晰和可重复使用


-1

这是另一种方式:

using Newtonsoft.Json.Linq;

internal class DymanicTest
{
    public static string Json = @"{
            ""AED"": 3.672825,
            ""AFN"": 56.982875,
            ""ALL"": 110.252599,
            ""AMD"": 408.222002,
            ""ANG"": 1.78704,
            ""AOA"": 98.192249,
            ""ARS"": 8.44469
}";

    public static void Run()
    {
        dynamic dynamicObject = JObject.Parse(Json);

        foreach (JProperty variable in dynamicObject)
        {
            if (variable.Name == "AMD")
            {
                var value = variable.Value;
            }
        }
    }
}

2
您从哪里得到的问题是有关测试JObject属性的想法?您的答案仅限于在其属性上公开IEnumerable的对象/类。不能保证dynamicdynamic关键字是广泛的主题。去检查,如果你可以测试Countdynamic foo = new List<int>{ 1,2,3,4 }这样的
羽蛇神
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.