Possible Duplicate:
Making a generic property
I'm not quite sure how to do that, but what I would like to do is to create a special type of property that will perform specific tasks at the get and set, and will be defined on generic type.
For example, when writing this:
MyProp<String> name;
a pre-defined get and set will be performed on the string value.
How can that be done?
Thanks!
This question is related to
c#
generics
properties
You can make a generic class like this:
public class MyProp<T>
{
private T _value;
public T Value
{
get
{
// insert desired logic here
return _value;
}
set
{
// insert desired logic here
_value = value;
}
}
public static implicit operator T(MyProp<T> value)
{
return value.Value;
}
public static implicit operator MyProp<T>(T value)
{
return new MyProp<T> { Value = value };
}
}
...then use it in a class like so:
class SomeClass
{
public MyProp<int> SomeProperty { get; set; }
}
The implicit operators means that you do not need to explicitly set or get the Value property of MyProp, but can write code to access the value in a more "natural" way:
SomeClass instance = new SomeClass();
instance.SomeProperty = 32;
int someInt = instance.SomeProperty;
You just declare the property the normal way using a generic type:
public MyType<string> PropertyName { get; set; }
If you want to call predefined methods to do something in the get or set, implement the property getter/setter to call those methods.
You would need to create a generic class named MyProp. Then, you will need to add implicit or explicit cast operators so you can get and set the value as if it were the type specified in the generic type parameter. These cast operators can do the extra work that you need.
Okay, I'll bite. You want something like this: If you declare a "property" like this:
Update: I'm now pretty sure that Fredrik Mörk answered your question and gave a solution. I'm not really happy with the idea, but it seems to answer exactly what I understood from your question.
public class PropertyFoo {
public MyProp<String> Name;
}
this ends up as
public class PropertyFoo {
public string Name {
get { /* do predefined stuff here */ }
set { /*other predefined stuff here */ }
}
}
No. Not possible and not a property, really. Look for template/snippet support in your IDE.
public class MyProp<T>
{
...
}
public class ClassThatUsesMyProp
{
public MyProp<String> SomeProperty { get; set; }
}
You cannot 'alter' the property syntax this way. What you can do is this:
class Foo
{
string MyProperty { get; set; } // auto-property with inaccessible backing field
}
and a generic version would look like this:
class Foo<T>
{
T MyProperty { get; set; }
}
Source: Stackoverflow.com