|
|
Tony_P wrote: It's actually amazing to see that people still do stuff like that nowadays
where have you seen people using code like i suggested?
If only MySelf.Visible was more than just a getter...
A person can produce over 5 times there own body weight in excrement each year... please re-read your questions before posting
|
|
|
|
|
There's a one-liner for that too.
number+=number.Contains(',')?new String('0',number.indexOf(',')-number.Length+3):",00";
Despite everything, the person most likely to be fooling you next is yourself.
modified on Monday, February 16, 2009 4:58 PM
|
|
|
|
|
very nice
If only MySelf.Visible was more than just a getter...
A person can produce over 5 times there own body weight in excrement each year... please re-read your questions before posting
|
|
|
|
|
for example :
double dbl = 344.5;
string dblInStr = dbl.ToString("F2"); // 344,50
double dbl = 333;
string dblInStr = dbl.ToString("F2"); // 333,00
|
|
|
|
|
Hi Guys,
I'd like to dynamically assign values to a known class instance based on the Property name. An example describes perfectly what I want to do: There is a class
public class AClass
{
public string _aValue;
public string AValue
{
get { return _aValue; }
set { _aValue = value; }
}
}
and I want to assing value to AClass.AValue without actually explicitly writing:
AClass aInstance = new AClass();
aInstance.AValue = "value";
and now comes the best part. I'd like to avoid reflection as much as possible, because performance matters. I could go and look for a property named "AValue" and do
typeof(AClass).GetProperty("AValue").SetValue(aInstance, "value", null);
however that's veery slow. It's got to be possible to do that some other way, Linq works like this and it's not slow.
any ideas?
zilo
|
|
|
|
|
Could try creating a method in the class that takes param name and value, then do a switch and assign the value to the property required
If only MySelf.Visible was more than just a getter...
A person can produce over 5 times there own body weight in excrement each year... please re-read your questions before posting
|
|
|
|
|
thanks for the idea, for now something like that is my workaround solution.
However I wanted to avoid writing special code into the AClass itself as well. I was thinking of something generic that could either AClass inherit from or a Wrapper class.
zilo
|
|
|
|
|
If it's only the one property you could use an implicit operator overload.
public class AClass
{
public AClass() : this(string.Empty) { }
private AClass(string aValue)
{
AValue = aValue;
}
public static implicit operator AClass(string aValue)
{
return new AClass(aValue);
}
public string AValue
{
get;
set;
}
}
AClass aInstance = "Test String";
Console.WriteLine(aInstance.AValue);
DaveBTW, in software, hope and pray is not a viable strategy. (Luc Pattyn)Visual Basic is not used by normal people so we're not covering it here. (Uncyclopedia)
|
|
|
|
|
Interesting idea, but... It's not only one, there will be many properties like this within AClass. And it needs to be done outside of constructor.
zilo
|
|
|
|
|
Maybe extension methods could work. Create an extension method ToAClass for each type, and also pass the AClass instance.
public static class ExtensionMethods
{
static public void SetAClass(this string value, AClass instance)
{
instance.AString = value;
}
static public void SetAClass(this int value, AClass instance)
{
instance.AInt = value;
}
}
public class AClass
{
public string AString
{
get;
set;
}
public int AInt
{
get;
set;
}
}
AClass aInstance = new AClass();
"Test string".SetAClass(aInstance);
123.SetAClass(aInstance);
DaveBTW, in software, hope and pray is not a viable strategy. (Luc Pattyn)Visual Basic is not used by normal people so we're not covering it here. (Uncyclopedia)
|
|
|
|
|
Anyhow, whether is it extension methods or not, I'll have to create them dynamically using reflection and then just call those methods. I think I have a better idea now, thanks
zilo
|
|
|
|
|
Zilo(svk) wrote: and I want to assing value to AClass.AValue without actually explicitly writing
It's difficult to answer without knowing why. Is it because you don't know the type at compile time?
|
|
|
|
|
Yes. I'm loading the class from dll as
Assembly.LoadFile(string file);
And I'd like to keep AClass as simple as possible, without any specific code to read or write values into it. It's just a data container.
zilo
|
|
|
|
|
Well, LINQ knows the types of data objects at compile time, so there's no similarity there.
Without reflection, I guess your best bet is emitting the IL directly[^].
|
|
|
|
|
It doesn't have to, I'm using those classes to work with linq as well and it's working fine. Thanks for the suggestion, that looks to be the only way to go.
zilo
|
|
|
|
|
Zilo(svk) wrote: I'm using those classes to work with linq as well and it's working fine
Now I'm curious - can you paste a snippet of code that does that? I can't imagine LINQ working without you specifying the type somewhere (unless it's an anonymous type, of course).
|
|
|
|
|
I ment the classes are not present withing the same solution or assembly when compiling the code. When working with linq, I'm using strong types. This is a sample of one of the classes:
[Table(Name = "Books")]
public partial class Book : IDALEntity
{
private int _BookId;
private string _Title;
private int _Price;
private int _PublisherID;
public Book()
{ }
[Column(Storage = "_BookId", AutoSync = AutoSync.OnInsert, DbType = "Int NOT NULL", IsPrimaryKey = true)]
public int BookId
{
get
{
return this._BookId;
}
set
{
this._BookId = value;
}
}
...
}
zilo
|
|
|
|
|
Well, LINQ uses reflection to read the custom attributes you provide for each property, so that it can map them to database columns. I guess they do it just once and then generate dynamic code to do the actual translation from SQL results to object property assignments.
|
|
|
|
|
Basically, you are searching for an alternative to Reflection, right?
Calin
|
|
|
|
|
Kind of. Something that does the job but keeps the speed on same level as direct access.
zilo
|
|
|
|
|
I think you could try by using Dynamic Invocation.
Calin
|
|
|
|
|
Do you suggest to create a method using reflection on the fly:
void AssingAValue(AClass aInstance, object value)
{
aInstance.AValue = value;
}
and then just call this method?
zilo
|
|
|
|
|
yes, so you can dynamically change the AValue property.
Calin
|
|
|
|
|
Also, you can use TypeDescriptor , and PropertyDescriptor .
Calin
|
|
|
|