C# – Cannot access Object fields using fieldinfo

cobservablecollectionreflection

I have an method that takes in an observable collection (returned from a webservice) of objects and analyzes them according to their attributes.

Here is the code snippet from the method

private double analyze(ObservableCollection mobjColl)
{

        FieldInfo fi = null;

        foreach (MyApp.MyObj oi in mobjColl)
        {

        if(oi.pressure.Equals("high"){

            fi = oi.GetType().GetField("air");

            .....
        }
        }
        return someval;
    }

My problem is that the fieldinfo fi is always null. I can access every field of the object (within foreach) using the objects name however the fieldinfo object is never populated. I even tried using GetFields method but it does not return an array…

P.S : the object fields are public. Using bindingflags in getfield didnt help either.

Best Answer

I don't believe objects returned from web services expose public fields. You might be thinking of properties instead. If you try GetProperty("air") you'll probably get something back.

Related Solutions

C# – How to create a new object instance from a Type

The Activator class within the root System namespace is pretty powerful.

There are a lot of overloads for passing parameters to the constructor and such. Check out the documentation at:

http://msdn.microsoft.com/en-us/library/system.activator.createinstance.aspx

or (new path)

https://docs.microsoft.com/en-us/dotnet/api/system.activator.createinstance

Here are some simple examples:

ObjectType instance = (ObjectType)Activator.CreateInstance(objectType);

ObjectType instance = (ObjectType)Activator.CreateInstance("MyAssembly","MyNamespace.ObjectType");

C# – Should ‘using’ directives be inside or outside the namespace

There is actually a (subtle) difference between the two. Imagine you have the following code in File1.cs:

// File1.cs
using System;
namespace Outer.Inner
{
    class Foo
    {
        static void Bar()
        {
            double d = Math.PI;
        }
    }
}

Now imagine that someone adds another file (File2.cs) to the project that looks like this:

// File2.cs
namespace Outer
{
    class Math
    {
    }
}

The compiler searches Outer before looking at those using directives outside the namespace, so it finds Outer.Math instead of System.Math. Unfortunately (or perhaps fortunately?), Outer.Math has no PI member, so File1 is now broken.

This changes if you put the using inside your namespace declaration, as follows:

// File1b.cs
namespace Outer.Inner
{
    using System;
    class Foo
    {
        static void Bar()
        {
            double d = Math.PI;
        }
    }
}

Now the compiler searches System before searching Outer, finds System.Math, and all is well.

Some would argue that Math might be a bad name for a user-defined class, since there's already one in System; the point here is just that there is a difference, and it affects the maintainability of your code.

It's also interesting to note what happens if Foo is in namespace Outer, rather than Outer.Inner. In that case, adding Outer.Math in File2 breaks File1 regardless of where the using goes. This implies that the compiler searches the innermost enclosing namespace before it looks at any using directive.

Best Answer

Related Solutions

C# – How to create a new object instance from a Type

C# – Should ‘using’ directives be inside or outside the namespace

Related Topic