|
I guess in my particular case, it didn't make a lot of sense because, for this particular class, it's the same as:
public SearchCriteria() {
m_year = 2000;
m_month = 1;
}
And in my mind this is much more readable and efficient. If the thing was doing more work with the values, I could understand the use of this construct.
The other constructor looks like:
public SearchCriteria(int yr, int mo) {
m_year = yr;
m_month = mo;
}
I think it's some contractor's idea to getting more hours, making the code harder to read, and hoping that the company will be dependent on him in the future. I'm seeing quite a few things which are obviously that kind of trick, but this one got me interested as to whether there was a good reason for it or not. This particular class is way overblown... it's one of those classes that could have just as easily been a struct, because it doesn't actually do any processing, it's only an object to aggregate some values together and it never actually does anything with those values besides store them.
|
|
|
|
|
There is a rationale for using this construct:
Imagine the SearchCriteria class is modified to include additional initializations:
private string m_whereClause;
public SearchCriteria(int yr, int mo)
{
m_year = yr;
m_month = mo;
m_searchRX = new Regex(....); // precompile search criteria
m_resultCache = null;
}
using SearchCriteria() : this(2000, 1) {} keeps the change and additional code in one place.
Maybe this does not make any sense for the class you are using, but generally I would recommend using the this(...) in such a scenario.
We are a big screwed up dysfunctional psychotic happy family - some more screwed up, others more happy, but everybody's psychotic joint venture definition of CP blog: TDD - the Aha! | Linkify!| FoldWithUs! | sighist
|
|
|
|
|
Yes I agree. It does seem handy in that case, and I'll keep it in mind if that kind of situation ever arises. In this particular case though, it's just weird.
|
|
|
|
|
I have the following code:
public enum LogLevel { Quiet=0, Noise=1, Verbose=2 };
private LogLevel IntToLogLevel(int value, LogLevel defaultValue)
{
LogLevel enumValue = defaultValue;
if (Enum.IsDefined(typeof(LogLevel), value))
{
enumValue = (LogLevel)value;
}
return enumValue;
}
I want to make the IntToLoglevel() function generic enough to use for any enum type. Is what I want to do possible?
"Why don't you tie a kerosene-soaked rag around your ankles so the ants won't climb up and eat your candy ass..." - Dale Earnhardt, 1997 ----- "...the staggering layers of obscenity in your statement make it a work of art on so many levels." - Jason Jystad, 10/26/2001
|
|
|
|
|
<font color="Blue">static</font> <font color="Blue">void</font> Main<font color="DarkBlue">(</font><font color="Blue">string</font><font color="DarkBlue">[]</font> args<font color="DarkBlue">)</font>
<font color="DarkBlue">{</font>
LogLevel ll <font color="DarkBlue">=</font> IntToLogLevel<font color="DarkBlue"><</font>LogLevel<font color="DarkBlue">></font><font color="DarkBlue">(</font><font color="Red">2</font><font color="DarkBlue">,</font> LogLevel<font color="DarkBlue">.</font>Noise<font color="DarkBlue">)</font><font color="DarkBlue">;</font>
Console<font color="DarkBlue">.</font>WriteLine<font color="DarkBlue">(</font>ll<font color="DarkBlue">)</font><font color="DarkBlue">;</font>
LogLevel ll2 <font color="DarkBlue">=</font> IntToLogLevel<font color="DarkBlue"><</font>LogLevel<font color="DarkBlue">></font><font color="DarkBlue">(</font><font color="Red">4</font><font color="DarkBlue">,</font> LogLevel<font color="DarkBlue">.</font>Noise<font color="DarkBlue">)</font><font color="DarkBlue">;</font>
Console<font color="DarkBlue">.</font>WriteLine<font color="DarkBlue">(</font>ll2<font color="DarkBlue">)</font><font color="DarkBlue">;</font>
<font color="DarkBlue">}</font>
<font color="Blue">public</font> <font color="Blue">enum</font> <font color="Teal">LogLevel</font> <font color="DarkBlue">{</font> Quiet <font color="DarkBlue">=</font> <font color="Red">0</font><font color="DarkBlue">,</font> Noise <font color="DarkBlue">=</font> <font color="Red">1</font><font color="DarkBlue">,</font> Verbose <font color="DarkBlue">=</font> <font color="Red">2</font> <font color="DarkBlue">}</font><font color="DarkBlue">;</font>
<font color="Blue">static</font> T IntToLogLevel<font color="DarkBlue"><</font>T<font color="DarkBlue">></font><font color="DarkBlue">(</font><font color="Blue">int</font> value<font color="DarkBlue">,</font> T defaultValue<font color="DarkBlue">)</font>
<font color="DarkBlue">{</font>
T enumValue <font color="DarkBlue">=</font> defaultValue<font color="DarkBlue">;</font>
<font color="Blue">if</font> <font color="DarkBlue">(</font>Enum<font color="DarkBlue">.</font>IsDefined<font color="DarkBlue">(</font><font color="Blue">typeof</font><font color="DarkBlue">(</font>T<font color="DarkBlue">)</font><font color="DarkBlue">,</font> value<font color="DarkBlue">)</font><font color="DarkBlue">)</font>
<font color="DarkBlue">{</font>
enumValue <font color="DarkBlue">=</font> <font color="DarkBlue">(</font>T<font color="DarkBlue">)</font><font color="DarkBlue">(</font><font color="Blue">object</font><font color="DarkBlue">)</font>value<font color="DarkBlue">;</font>
<font color="DarkBlue">}</font>
<font color="Blue">return</font> enumValue<font color="DarkBlue">;</font>
<font color="DarkBlue">}</font>
|
|
|
|
|
Brilliant.
"Why don't you tie a kerosene-soaked rag around your ankles so the ants won't climb up and eat your candy ass..." - Dale Earnhardt, 1997 ----- "...the staggering layers of obscenity in your statement make it a work of art on so many levels." - Jason Jystad, 10/26/2001
|
|
|
|
|
If you're using .NET 3.5, there's always this way:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace TestEnumExtension
{
public enum LogLevel { Quiet = 0, Noise = 1, Verbose = 2 }
class Program
{
static void Main(string[] args)
{
int outp = 12;
LogLevel level = outp.ConvertEnum(LogLevel.Quiet);
Console.WriteLine(level.ToString());
}
}
public static class Utility
{
public static T ConvertEnum<T>(this int value, T defaultValue)
{
T e = defaultValue;
if (Enum.IsDefined(typeof(T), value))
{
e = (T)(object)value;
}
return e;
}
}
} With thanks to Leppie for providing the basis for this with the answer above.
modified on Friday, February 01, 2008 5:39:53 PM
|
|
|
|
|
Thats just plain evil, for too many reasons
|
|
|
|
|
I've just edited the post so that you get the credit for the inspiration. It's only right and proper.
|
|
|
|
|
John wrote most of the code
|
|
|
|
|
And I meant evil in a coding way, just imagine having to import the class everywhere, and have this pesky extension method on you int's!
|
|
|
|
|
It's all right - I didn't think anything else about the evil. I'm still of two minds as to extension methods.
|
|
|
|
|
I dont think it's very usefull, except for the 2 LINQ cases. Now that I think of it, extension methods should be limited to interfaces only, that would make sense, else you just plain lazy to code decent
|
|
|
|
|
leppie wrote: having to import the class everywhere
Yeah, I'm not very thrilled with extension methods either.
The compiler writer(s) should have spent the time working on virtual constructors.
|
|
|
|
|
I don't understand how that works. How is ConvertEnum a method of the int outp? Is it because of Linq?
"Why don't you tie a kerosene-soaked rag around your ankles so the ants won't climb up and eat your candy ass..." - Dale Earnhardt, 1997 ----- "...the staggering layers of obscenity in your statement make it a work of art on so many levels." - Jason Jystad, 10/26/2001
|
|
|
|
|
It's because I've extended the type int to include a method called ConvertEnum. Have a look at extension methods to get an understanding as to how it works.
|
|
|
|
|
Nice - take a look above for the extension method version.
|
|
|
|
|
Those are pretty good, but I still prefer an Attribute, at least to reflect the original developer's intent.
|
|
|
|
|
Hello,
Can someone point me towards a good tutorial which will walk me through how to
use C++ and Fortran code with/from C#.
Is it possible for me to use the object-files produced when compiling C++/Fortran
and use them in C#?
I'm looking to put a nice GUI around some old code.
Thanks........
|
|
|
|
|
You can use C/C++ built DLLs in C#. Look into p/invoke. Assuming the fortran code was compiled into c++ compatible DLLs as well you could you it as well.
Otherwise [Microsoft is] toast in the long term no matter how much money they've got. They would be already if the Linux community didn't have it's head so firmly up it's own command line buffer that it looks like taking 15 years to find the desktop.
-- Matthew Faithfull
|
|
|
|
|
hi thanks for the reply. I did look into DLLs but i didn't get one to work.
do you have a tutorial link on DLLS?
Is there an easy way to create C++ compatible DLLs using Fortran code?
And can classes get incorporated into DLLs? or just methods?
Is it not possible to use the object files then? I'd rather not translate the Fortran.
|
|
|
|
|
Assuming you have the source available the pinvoke wizard should be able to help with getting the declarations to do the import correct.
http://www.paulyao.com/resources/tools/pinvoke.asp[^]
I suggest looking for a fortran board for assistance with getting DLLs that can be called by standard win32 applications. This isnt a good place to try and find someone with that skill.
You can import structs, classes, and stand alone function calls from a native dll.
You can't use object files. They're a semi compiled format and native code can't be directly compiled into managed code. You need dlls. If you can use the obj files in a windows C/C++ compiler you should be able to create a dll containing all of thier functionality for use via p/invoke.
Otherwise [Microsoft is] toast in the long term no matter how much money they've got. They would be already if the Linux community didn't have it's head so firmly up it's own command line buffer that it looks like taking 15 years to find the desktop.
-- Matthew Faithfull
|
|
|
|
|
|
Ylno wrote: Is it possible for me to use the object-files produced when compiling C++/Fortran
and use them in C#?
It might be possible. If it is possible it would likely be easier to accomplish if you knew about Computer Programming.[^]
The process of writing source codes requires expertise in many different subjects, including knowledge of the application domain, specialized algorithms, and formal logic.
led mike
|
|
|
|
|
Thanks led mike. I did think about learning programming but I thought I'd try C# first.
I guess it's time to bite the bullet.
led mike wrote: It might be possible. If it is possible it would likely be easier to accomplish if you knew about Computer Programming.[^]
-- that's exactly the type of comment that makes people stay away.
|
|
|
|