CODEWITHSUNDEEP
c#.net
Canella
Canella

Reputation: 454

Trying to get a literal via reflection

Suppose I have a the following code:

Container.cs

public class Container
{
    public readonly string IdType;

    public Container( string aIdType )
    {
        IdType = aIdType;
    }
}

SuperContainerA .cs

public class SuperContainerA : Container
{
    public SuperContainerA( /*x parameters*/ ) : base("A") {}
}

SuperContainerB.cs

public class SuperContainerB : Container
{
    public SuperContainerB(  /*y parameters*/ ) : base("B") {}
}

SuperContainerToTheInfinityAndBeyond.cs

public class SuperContainerB : Container
{
    public SuperContainerB(  /*y parameters*/ ) : base("It's Over 9000!") {}
}

Based on that, what I'm trying to retrieve is the "A" and "B" that are being sent to the TypeId from the constructor.

The catch here is... I need to retrieve those values during the initialization of the program, before creating an instance of those classes, so I thought that using reflection is my best bet here. (Note: Creating an instance of the classes to retrieve the value would be valid if the number of parameters for each constructor would be the same, but they can change. :()

Is it possible to use reflection to check the literals of my source code and/or Assemblies? (If I can see something like the source code, then I can use Regex to get the value.)(Note: Including the sources as resource files to my program is not an option :P)

I'm thinking of declaring constants to hold the value and force an naming rule on then, so that I could use reflection later to grab then back. Something like ...

public class SuperContainerA
{
    public const string ctIdType = "A";
}

public class SuperContainerB
{
    public const string ctIdType = "B";
}

... But I'm not sure if this is the best approach to this problem, since I won't have anything to help me check if these consts have been declared and if they got the proper name during compile time.

Actually, if the language had some kind of static inheritance, this would help a lot in this situation, but I hear some programmers complaing that static inheritance is more of an head ache than a cure.

Anyway, I'm searching for alternatives. Any idea is welcome.

Upvotes: 1

Views: 154

Answers (2)

Daren Thomas
Daren Thomas

Reputation: 70324

Attributes to the rescue!

public class IdTypeAttribute: Attribute
{
    public string IdType { get; private set; }

    public IdTypeAttribute(string idType)
    {
        IdType = idType;
    }
}

[IdType("B")]
public class SuperContainerB: Container
{
    // whatever you like...
}

You can then access the Attribute via reflection. Easy enough to do...

var type = typeof(SuperContainerB);
var attribute = (IdTypeAttribute)type.GetCustomAttributes(
    typeof(IdTypeAttribute), false)[0];
var idType = attribute.IdType;

Upvotes: 4

Morten Mertner
Morten Mertner

Reputation: 9474

Why not simply use the concrete type to look up the string value that you seem to want associated with it?

public class SuperA : Container 
{
    public string IdType { get { return IdTypeFactory.Get( GetType() ); } }
}

public static class IdTypeFactory
{
    public static string Get( Type containerType ) { ... }
}

The primary benefit of this solution would be to gather all your string literals in one central location. Alternatively, go with the abstract super class.

Upvotes: 1

Related Questions