Dinamik bir değişkente bir özelliğin bulunup bulunmadığını test edin

Durumum çok basit. Kodumu bir yerde bu var:

dynamic myVariable = GetDataThatLooksVerySimilarButNotTheSame();

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

Yani, temelde sorum dinamik değişkenimde belirli bir özelliğin kullanılabilir olduğunu (istisna atmadan) nasıl kontrol edeceğim. Yapabilirdim GetType()ama nesnenin türünü bilmem gerekmediğinden bundan kaçınmayı tercih ederim. Gerçekten bilmek istediğim, bir özellik (ya da bu hayatı kolaylaştırır yöntemi) kullanılabilir olup olmadığıdır. İşaretçi var mı?

Bence bir dynamicDinamik bağlamanın C # derleyicisinde işlenme biçimini yeniden uygulamadığınız sürece, değişkenin erişmeye çalışmadan belirli bir üyesi . C # belirtimine göre, uygulama tanımlı olduğu için muhtemelen çok fazla tahmin içerir.

Dolayısıyla, üyeye erişmeye ve başarısız olursa bir istisna yakalamaya çalışmalısınız:

dynamic myVariable = GetDataThatLooksVerySimilarButNotTheSame();

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

Martijn'in cevabı ile svick'in cevabı arasında bir karşılaştırma yapacağımı düşündüm ...

Aşağıdaki program aşağıdaki sonuçları döndürür:

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

Sonuç olarak yansıma kullanmanızı öneririm. Aşağıya bakınız.

Mülayim yorumuna cevap:

Oranlar reflection:exception100000 iterasyon için kenelerdir:

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

... yeterince adil - ~ 1 / 47'den daha düşük bir olasılıkla başarısız olmasını bekliyorsanız, istisna için gidin.

Yukarıda GetProperties()her seferinde koştuğunuz varsayılmaktadır . GetProperties()Sözlük veya benzeri her türün sonucunu önbelleğe alarak işlemi hızlandırabilirsiniz . Aynı tür kümeleri tekrar tekrar kontrol ediyorsanız bu yardımcı olabilir.

Belki yansıma kullanın?

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

Birisine yardım etmesi durumunda:

Yöntem ise GetDataThatLooksVerySimilarButNotTheSame()bir döndürür ExpandoObjectayrıca bir yayın yapabilirsiniz IDictionaryişaretlemeden önce.

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

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

Bunun iki yaygın çözümü çağrı yapmak ve yakalamak RuntimeBinderException, çağrıyı kontrol etmek için yansıma kullanmak veya bir metin formatına serileştirmek ve oradan ayrıştırmaktır. İstisnalarla ilgili sorun, çok yavaş olmalarıdır, çünkü biri oluşturulduğunda, geçerli çağrı yığını serileştirilir. JSON veya benzer bir şeye seri hale getirme de benzer bir cezaya çarptırılır. Bu bizi yansıma ile terk eder, ancak yalnızca altta yatan nesne aslında üzerinde gerçek üyelere sahip bir POCO ise işe yarar. Bir sözlük, COM nesnesi veya harici bir web hizmeti etrafındaki dinamik bir sarıcıysa, yansıma yardımcı olmaz.

Diğer bir çözüm DynamicMetaObjectde, DLR'nin gördüğü gibi üye adlarını almak için kullanılır . Aşağıdaki örnekte Dynamic, Agealanı sınamak ve görüntülemek için statik bir sınıf ( ) kullanıyorum .

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

Denis'in yanıtı JsonObjects kullanarak başka bir çözüm düşünmemi sağladı,

üstbilgi özelliği denetleyicisi:

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

ya da belki daha iyisi:

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

Örneğin:

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

Benzer bir sorunla karşılaştım ama birim testlerde.

SharpTestsEx kullanarak bir özelliğin olup olmadığını kontrol edebilirsiniz. Bu denetleyicileri kullanıyorum, çünkü JSON nesnesi dinamik olduğundan, birisi adı değiştirebilir ve javascript veya başka bir şeyde değiştirmeyi unutabilir, bu yüzden denetleyiciyi yazarken tüm özellikleri test etmek güvenliğimi arttırmalıdır.

Misal:

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

Şimdi, SharTestsEx kullanarak:

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

Bunu kullanarak, "gerekir (). NotThrow ()" kullanarak tüm özellikleri test.

Muhtemelen konu dışı, ama birisi için yararlı olabilir.

@Karask'ın cevabından sonra, işlevi böyle bir yardımcı olarak sarabilirsiniz:

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

Benim için çalışıyor:

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

Dinamik olarak kullanılan türü kontrol ederseniz, her özellik erişimi için bir değer yerine bir demet döndüremez misiniz? Gibi bir şey...

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

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

Muhtemelen naif bir uygulama, ancak her seferinde bunlardan birini dahili olarak oluşturursanız ve bunu gerçek değer yerine döndürürseniz Exists, her mülk erişimini kontrol edebilir ve daha sonra Valuedeğerin default(T)(ve ilgisiz) değerinde olup olmadığını isabet ettirebilirsiniz .

Bununla birlikte, dinamik çalışma hakkında bazı bilgiler eksik olabilir ve bu uygulanabilir bir öneri olmayabilir.

Benim durumumda, belirli bir ada sahip bir yöntemin varlığını kontrol etmem gerekiyordu, bu yüzden bunun için bir arayüz kullandım

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

Ayrıca, arayüzler sadece yöntemlerden daha fazlasını içerebilir:

Arabirimler yöntemleri, özellikleri, olayları, dizinleyicileri veya bu dört üye türünün herhangi bir kombinasyonunu içerebilir.

Gönderen: Arabirimler (C # Programlama Kılavuzu)

Zarif ve istisnaları hapsetmeye veya yansımayla oynamaya gerek yok ...

Bu gerçekten eski bir yazı olduğunu ama burada çalışmak için basit bir çözümdür biliyoruz dynamictip c#.

1. doğrudan özellikleri sıralamak için basit yansıma kullanabilir
2. veya objectgenişletme yöntemini kullanabilir
3. veya GetAsOrDefault<int>varsa değeri olan yeni veya güçlü bir nesne almak için yöntemi kullanın.

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

Gibi ExpandoObjectINHERITS IDictionary<string, object>aşağıdaki denetimini kullanabilirsiniz

dynamic myVariable = GetDataThatLooksVerySimilarButNotTheSame();

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

Bu kontrolü gerçekleştirmek için, kodu daha temiz ve yeniden kullanılabilir hale getirecek bir yardımcı program yapabilirsiniz.

Diğer yol:

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