Develop Reference

Adding header information to an enum using a custom attribute in C#

I am able to create and build my own attributes and use them from within an enum, but I am unable to use these attributes as header information to an enum.
For instance, consider the following enum:
[EnumSize(0x30000)]
public enum Memories
{
[MemSize(0x10000)]
[Description("Memory0")]
Memory0Base = 0x00000,
[MemSize(0x10000)]
[Description("Memory1")]
Memory1Base= 0x10000,
[MemSize(0x10000)]
[Description("Memory2")]
Memory2Base= 0x20000
}
Now, I have created both EnumSize and MemSize attributes in the following way:
public class EnumSizeAttribute : System.Attribute
{
private int _value;
public EnumSizeAttribute(int value)
{
_value = value;
}
public int Value
{
get { return _value; }
}
}
And made it more "access friendly" (meaning I can do something like this: Memories.Memory2Base.MemSize() or Memories.EnumSize()):
public static string EnumSize<T>(this T value)
{
FieldInfo fi = value.GetType().GetField(value.ToString());
EnumSizeAttribute[] attributes = (EnumSizeAttribute[])fi.GetCustomAttributes(typeof(EnumSizeAttribute), false);
if (attributes.Length > 0)
return attributes[0].EnumSize();
else
return value.ToString();
}
Now, although it generates no compilation error when using it as a header to my enum as here below, I am unable to get the EnumSize by doing "Memories.EnumSize()".
[EnumSize(0x30000)]
public enum Memories
{
...
}
Any tip on how to get it to work would be very much appreciated.

Memories is a type not a field, so you would need to do something like this:
public static string EnumSize<T>() where T : struct, Enum
{
EnumSizeAttribute attribute = typeof(T).GetCustomAttribute<EnumSizeAttribute>();
return attribute?.Value.ToString();
}
And use as follows:
string size = EnumSize<Memories>();
You won't be able to call this as an extension method like you have with MemSize though.
The only way to do that would be to extend Type, for example:
public static string EnumSize(this Type type)
{
EnumSizeAttribute attribute = type.GetCustomAttribute<EnumSizeAttribute>();
return attribute?.Value.ToString();
}
string size = Memories.EnumSize();
But that would be available to use with all types, not just enums, which is probably not what you want.
Of course you could throw an exception if it is used incorrectly:
public static string EnumSize(this Type type)
{
if (!type.IsEnum)
{
throw new InvalidOperationException("EnumSize only applies to enums");
}
EnumSizeAttribute attribute = type.GetCustomAttribute<EnumSizeAttribute>();
return attribute?.Value.ToString();
}
But I would probably stick to the first example.

C# Attribute check is an value equals the constructor argument and get constructor values

How can i check that some string is equal to the "constructor" arguments of an attribute?
And how to get all constructor values (TestArg1, TestArg2)?
struct MyData
{
[MyAttr("TestArg1", "TestArg2")] //check that some string equals TestArg1/TestArg2
public string TestArg;
}

This primarily depends on what attribute you're looking at and how it's coded. See the code below as an example on how to do what you're asking.
//The attribute we're looking at
public class MyAtt : System.Attribute
{
public string name;
public string anotherstring;
public MyAtt(string name, string anotherstring)
{
this.name = name;
this.anotherstring = anotherstring;
}
}
public static class Usage
{
[MyAtt("String1", "String2")] //Using the attribute
public static string SomeProperty = "String1";
}
public static class Program
{
public static void Main()
{
Console.WriteLine(IsEqualToAttribute("String1"));
Console.WriteLine(IsEqualToAttribute("blah"));
Console.ReadKey();
}
public static bool IsEqualToAttribute(string mystring)
{
//Let's get all the properties from Usage
PropertyInfo[] props = typeof(Usage).GetProperties();
foreach (var prop in props)
{
//Let's make sure we have the right property
if (prop.Name == "SomeProperty")
{
//Get the attributes from the property
var attrs = prop.GetCustomAttributes();
//Select just the attribute named "MyAtt"
var attr = attrs.SingleOrDefault(x => x.GetType().Name == "MyAtt");
MyAtt myAttribute = attr as MyAtt; //Just casting to the correct type
if (myAttribute.name == mystring) //Compare the strings
return true;
if (myAttribute.anotherstring == mystring) //Compare the strings
return true;
}
}
return false;
}
}
As you can see we get the attribute off the property using reflection and then just compare the properties.
More info can be found here:
https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/attributes/accessing-attributes-by-using-reflection
As far as getting the constructor properties something along the lines of
typeof(MyAtt).GetConstructor().GetParameters()
Would retrieve the parameter details for the constructor.
There is also info on this in the Microsoft Docs: https://learn.microsoft.com/en-us/dotnet/api/system.reflection.customattributedata.constructor?view=netframework-4.7.2

Here is one way to do what you are asking for, but it's not particularly scaleable and requires a bunch of manual code to get working but may get you on the road to what you are trying to achieve. Assuming we have an attribute something like this that takes a string array in it's constructor:
public class MyAttrAttribute : Attribute
{
public string[] AllowedValues { get; }
public MyAttrAttribute(params string[] values)
{
AllowedValues = values;
}
}
You can change your field to be a property with a backing field. This allows you to override the set method and do your checking in there:
private string _testArg;
[MyAttr("TestArg1", "TestArg2")] //check that some string equals TestArg1/TestArg2
public string TestArg
{
get => _testArg;
set
{
var allowedValues = this.GetType() //Get the type of 'this'
.GetProperty(nameof(TestArg)) // Get this property
.GetCustomAttribute<MyAttrAttribute>() // Get the attribute
.AllowedValues; //Get the allowed values specified in the attribute
if(!allowedValues.Contains(value))
{
throw new ArgumentOutOfRangeException(nameof(value),
$"The value '{value}' is not allowed");
}
_testArg = value;
}
}
Having said all of this, I firmly believe that there is a better way to achieve what you are asking. For example, if you are restricted to a minimal set of values, then an enum would almost certainly be a better option than a string.

Accessing a custom attribute from within an instanced object

I'm trying to find a way to get access to attributes which have been applied at the property level from within an object, but am hitting a brick wall. It appears that the data is stored at the type level, but I need it at the property level.
Here's an example of what I'm trying to make:
public class MyClass
{
[MyAttribute("This is the first")]
MyField First;
[MyAttribute("This is the second")]
MyField Second;
}
public class MyField
{
public string GetAttributeValue()
{
// Note that I do *not* know what property I'm in, but this
// should return 'this is the first' or 'this is the second',
// Depending on the instance of Myfield that we're in.
return this.MyCustomAttribute.value;
}
}

Attributes aren't used that way. Attributes are stored in the class object that contains the attribute, not the member object/field that is declared within the class.
Since you want this to be unique per member, it feels more like this should be member data with MyField, something passed in by the constructor.
If you're hell bent on using an attribute, you could add code in your constructor that used reflection on every member that has an attribute attached to it an attempts to set its instance data to what you want, but you would need to make sure that all your MyField objects are fully constructed.
Alternately you could make your setter look like this:
private MyField _first;
[MyAttribute("This is the first")]
public MyField First {
get { return _first; }
set {
_first = value;
if (_first != null) {
_first.SomeAttribute = GetMyAttributeValue("First");
}
}
}
private string GetMyAttributeValue(string propName)
{
PropertyInfo pi = this.GetType().GetPropertyInfo(propName);
if (pi == null) return null;
Object[] attrs = pi.GetCustomAttributes(typeof(MyAttribute));
MyAttribute attr = attrs.Length > 0 ? attrs[0] as MyAttribute : null;
return attr != null ? attr.Value : null;
}

How to access a custom collection property by its property name

I want to implement a custom collection that contains instances of my class.
This is my class, a bit simplified here.
public class Property : IComparable<Property>
{
public string Name;
public string Value;
public string Group;
public string Id;
...
...
public int CompareTo(Property other)
{
return Name.CompareTo(other.Name);
}
}
I am adding instances of Property to a List collection
Public List<Property> properties;
I can iterate through properties or access a specific property through the index position.
I want to however be able to access the property by its Name such that
var myColor = properties["Color"].Value;
and I do not have an efficient way to do this. I assume that properties should be written as a custom list collection class to achieve this. Does anyone have a code sample I can look at?
Thanks for the help.

Easiest methods were already mentioned, but I see two:
Method 1
Convert to dictionary and lookup there.
var props = properties.ToDictionary( x => x.Name );
Property prop = props["some name"];
Method 2
Create your own collection type which would support indexing
by your arbitrary type.
public class PropertyCollection : List<Property>
{
public Property this[string name]
{
get
{
foreach (Property prop in this)
{
if (prop.Name == name)
return prop;
}
return null;
}
}
}
and use this collection instead
PropertyCollection col = new PropertyCollection();
col.Add(new Property(...));
Property prop = col["some name"];

You can use a Dictionary:
Dictionary<string, Property> properties = new Dictionary<string, Property>();
//you add it like that:
properties[prop.Name] = prop;
//then access it like that:
var myColor = properties["Color"];

Use a Dictionary<string,Property> for this purpose. The key will be the property name and the value will be the Property instance itself.

How to access the ConfigurationPropertyAttribute generated for a class with attributes ConfigurationProperty

I have an app with a pretty big configuration.
All configuration sections for each parameter are defined with .Net ConfigurationProperty attributes, that all have a DefaultValue property.
As our product becomes heavily customizable between countries, and even clients in one country, there is a Configurator.exe that enable to edit the big configuration file.
In this Configurator.exe, it would be really cool if I could have access to the many many many DefaultValue properties that has been defined... However, I don't have the single idea of how I could access those properties generated by the attributes.
e.g.:
public class MyCollection : ConfigurationElementCollection
{
public MyCollection ()
{
}
[ConfigurationProperty(MyAttr,IsRequired=false,DefaultValue=WantedValue)]
public MyAttributeType MyAttribute
{
//... property implementation
}
}
What I need is to programmatically access to the value WantedValue, the most generically as possible. (Otherwise I am to manually browse all the ConfigSections defined, collect the DefaultValues for each field, then check my configurator uses these values... )
In fancy it would look like: MyCollection.GetListConfigurationProperty() that would return ConfigurationPropertyAttribute objects on which I could call the Properties : Name, IsRequired, IsKey, IsDefaultCollection, and DefaultValue
Any idea ?

This is the class I happened to achieve which succeed in what I wanted to do:
I feed it with the ConfigSection type, the type of the defualt value of the field I want, and the string value of the field I want.
public class ExtensionConfigurationElement<TConfigSection, UDefaultValue>
where UDefaultValue : new()
where TConfigSection : ConfigurationElement, new()
{
public UDefaultValue GetDefaultValue(string strField)
{
TConfigSection tConfigSection = new TConfigSection();
ConfigurationElement configElement = tConfigSection as ConfigurationElement;
if (configElement == null)
{
// not a config section
System.Diagnostics.Debug.Assert(false);
return default(UDefaultValue);
}
ElementInformation elementInfo = configElement.ElementInformation;
var varTest = elementInfo.Properties;
foreach (var item in varTest)
{
PropertyInformation propertyInformation = item as PropertyInformation;
if (propertyInformation == null || propertyInformation.Name != strField)
{
continue;
}
try
{
UDefaultValue defaultValue = (UDefaultValue) propertyInformation.DefaultValue;
return defaultValue;
}
catch (Exception ex)
{
// default value of the wrong type
System.Diagnostics.Debug.Assert(false);
return default(UDefaultValue);
}
}
return default(UDefaultValue);
}
}