I have a horrible feeling I've been using a pattern for years...
-
I use this when the instances are going to be resource heavy - maybe have a couple of images in them - and / or I want one example of each instance through the whole system. So I have a private constructor, a static Dictionary containing all created instances, and a static method which fetches the instance:
private static Dictionary all = new Dictionary();
private MyClass(string name, List data )
{
...
all.Add(name, this);
}
public static MyClass Get(string name, List data)
{
if (all.ContainsKey(name)) return all[name];
return new MyClass(name, data);
}And it works really well. But ... is that a pattern? I hope not, I might have to stop using it ... :~
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay... AntiTwitter: @DalekDave is now a follower!
Seems like an Appalachian version of DI, just missing a banjo duel :)
But fortunately we have the nanny-state politicians who can step in to protect us poor stupid consumers, most of whom would not know a JVM from a frozen chicken. Bruce Pierson
Because programming is an art, not a science. Marc Clifton
I gave up when I couldn't spell "egg". Justine Allen -
I don't care for patterns in my code and I definitely don't care for vague terms like "clean" code. I only care for code that's short, safe to fail, easy to test, and understandable by a college freshman in less than 2 weeks. Nevertheless, please write about the patterns you think are worthwhile; preferably with a not-too-generic example. You might teach us something worthwhile. Also, if anyone knows of a must-read regarding the use of factory-pattern, please share. I really hate it and I'm looking for material to nuance my feelings towards it.
killbot5000 wrote:
understandable by a college freshman in less than 2 weeks.
If you can't explain your pattern in 5 minutes time, then you probably don't understand it. That is assuming that your freshman knows how to code :)
killbot5000 wrote:
Also, if anyone knows of a must-read regarding the use of factory-pattern, please share.
That's the pattern I'm opening the article with. May take another day or two.
killbot5000 wrote:
I really hate it
Yah, then you had the wrong explanation. Most important question to answer is always "what's in it for me?", and a factory has an easy to explain benefit :thumbsup:
Bastard Programmer from Hell :suss: If you can't read my code, try converting it here[^]
-
I use this when the instances are going to be resource heavy - maybe have a couple of images in them - and / or I want one example of each instance through the whole system. So I have a private constructor, a static Dictionary containing all created instances, and a static method which fetches the instance:
private static Dictionary all = new Dictionary();
private MyClass(string name, List data )
{
...
all.Add(name, this);
}
public static MyClass Get(string name, List data)
{
if (all.ContainsKey(name)) return all[name];
return new MyClass(name, data);
}And it works really well. But ... is that a pattern? I hope not, I might have to stop using it ... :~
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay... AntiTwitter: @DalekDave is now a follower!
Hmm. I don't see anything wrong with it, other than the name "
all" for the container, which isn't terribly descriptive. I've used similar "patterns", where constructors and destructors maintain global constructs as a side effect. The global constructs usually simplify finding one of the instances in some way, or in accessing the entire collection of 'live' instances. In some cases I also use them for orderly shutdowns, to insure that all instances get destroyed properly. For what it's worth, I've never read the GoF Patterns book.Software Zen:
delete this; -
I use this when the instances are going to be resource heavy - maybe have a couple of images in them - and / or I want one example of each instance through the whole system. So I have a private constructor, a static Dictionary containing all created instances, and a static method which fetches the instance:
private static Dictionary all = new Dictionary();
private MyClass(string name, List data )
{
...
all.Add(name, this);
}
public static MyClass Get(string name, List data)
{
if (all.ContainsKey(name)) return all[name];
return new MyClass(name, data);
}And it works really well. But ... is that a pattern? I hope not, I might have to stop using it ... :~
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay... AntiTwitter: @DalekDave is now a follower!
-
Because most patterns are a waste of time, but worshipped as the One True Holy Grail of Computing by those that learn it. And then force all applications they write to fit that pattern regardless of the appropriateness.
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay... AntiTwitter: @DalekDave is now a follower!
I was really wondering why you did not want to use a pattern so badly you would strike it from your code. I bought the GoF book, and was excited to be able to communicate better designs quicker. But, like you, I found zealots who used patterns like an indentation style. The could not code without them, and would convolute a simple program with them. I moved away from them, but use patterns (factory, most often) where they are clearly a solid approach, but NEVER worrying about doing it exactly as prescribed. But your comment felt like "I refuse to indent my code because there are indentation extremists"...
-
I use this when the instances are going to be resource heavy - maybe have a couple of images in them - and / or I want one example of each instance through the whole system. So I have a private constructor, a static Dictionary containing all created instances, and a static method which fetches the instance:
private static Dictionary all = new Dictionary();
private MyClass(string name, List data )
{
...
all.Add(name, this);
}
public static MyClass Get(string name, List data)
{
if (all.ContainsKey(name)) return all[name];
return new MyClass(name, data);
}And it works really well. But ... is that a pattern? I hope not, I might have to stop using it ... :~
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay... AntiTwitter: @DalekDave is now a follower!
OriginalGriff wrote:
And it works really well. But ... is that a pattern?
Yes. Multiton. Been around a long time. Multiton pattern - Wikipedia[^] The general idea is a Singleton per 'context' where the definition of the context is up the implementation.
-
I use this when the instances are going to be resource heavy - maybe have a couple of images in them - and / or I want one example of each instance through the whole system. So I have a private constructor, a static Dictionary containing all created instances, and a static method which fetches the instance:
private static Dictionary all = new Dictionary();
private MyClass(string name, List data )
{
...
all.Add(name, this);
}
public static MyClass Get(string name, List data)
{
if (all.ContainsKey(name)) return all[name];
return new MyClass(name, data);
}And it works really well. But ... is that a pattern? I hope not, I might have to stop using it ... :~
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay... AntiTwitter: @DalekDave is now a follower!
A cunning way of asking a programming question in the Lounge! ;P The
allfield should bereadonly, since you never replace it. You should probably specify an explicitStringComparerfor the dictionary, to make it more obvious that the key is case-sensitive. I'd be inclined to move theAddto the static method, and leave the constructor alone. I'd also replace theContainsKey/ indexer pair with a singleTryGetValuecall:public static MyClass Get(string name, List<string> data)
{
if (!all.TryGetValue(name, out MyClass instance)
{
instance = new MyClass(name, data);
all.Add(name, instance);
}return instance;}
And as Gerry said, if there's any possibility of the method being called by multiple threads, use a ConcurrentDictionary[^] instead:
private static readonly ConcurrentDictionary<string, MyClass> all = new ConcurrentDictionary<string, MyClass>(StringComparer.Ordinal);
public static MyClass Get(string name, List<string> data)
{
return all.GetOrAdd(name, key => new MyClass(key, data));
}Let's hope your class doesn't contain any unmanaged or disposable resources, since you'd have no way of knowing when to clean them up. :-D
"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer
-
killbot5000 wrote:
understandable by a college freshman in less than 2 weeks.
If you can't explain your pattern in 5 minutes time, then you probably don't understand it. That is assuming that your freshman knows how to code :)
killbot5000 wrote:
Also, if anyone knows of a must-read regarding the use of factory-pattern, please share.
That's the pattern I'm opening the article with. May take another day or two.
killbot5000 wrote:
I really hate it
Yah, then you had the wrong explanation. Most important question to answer is always "what's in it for me?", and a factory has an easy to explain benefit :thumbsup:
Bastard Programmer from Hell :suss: If you can't read my code, try converting it here[^]
If you can't explain your pattern in 5 minutes time, then you probably don't understand it.
True enough. I was only trying to explain our somewhat informal guideline at work; a junior should be able to master any one of our projects in a maximum of 2 weeks time, without any help from a senior. In general, we don't trust juniors to correctly identify or implement various patterns, so we don't approach our code as such. But, of course, we do want juniors to be able to work for clients almost instantly. *grin* It's mostly an effort of gathering/vetting the right tools; ones that are easy to use, easy to test, and with a low code footprint. Around 90% of our R&D is spend on simplifying the way we do things. But, to come back to factory pattern: I hate it because it often seems the right choice, but, for me, it has never panned out. Every time I try it out, I end up over-designing my data models and adding an abstraction layer I don't really need. In the end, I usually remove it and end up with (almost embarrassingly..) simple classes with distinct data. It can be infuriating. I try to come up with a clever looking data structure, hope factory pattern fits the bill, and *boom* suddenly I see there's no need for abstraction whatsoever, vastly reducing my test code and simplifying my DB design. :(
-
If you can't explain your pattern in 5 minutes time, then you probably don't understand it.
True enough. I was only trying to explain our somewhat informal guideline at work; a junior should be able to master any one of our projects in a maximum of 2 weeks time, without any help from a senior. In general, we don't trust juniors to correctly identify or implement various patterns, so we don't approach our code as such. But, of course, we do want juniors to be able to work for clients almost instantly. *grin* It's mostly an effort of gathering/vetting the right tools; ones that are easy to use, easy to test, and with a low code footprint. Around 90% of our R&D is spend on simplifying the way we do things. But, to come back to factory pattern: I hate it because it often seems the right choice, but, for me, it has never panned out. Every time I try it out, I end up over-designing my data models and adding an abstraction layer I don't really need. In the end, I usually remove it and end up with (almost embarrassingly..) simple classes with distinct data. It can be infuriating. I try to come up with a clever looking data structure, hope factory pattern fits the bill, and *boom* suddenly I see there's no need for abstraction whatsoever, vastly reducing my test code and simplifying my DB design. :(
killbot5000 wrote:
Every time I try it out, I end up over-designing my data models and adding an abstraction layer I don't really need.
Might be easier to not try it until you need one. To find a scenario where the use of it would be beneficial, you'd need some decent example. The abstract examples didn't help me much.
killbot5000 wrote:
*boom* suddenly I see there's no need for abstraction whatsoever, vastly reducing my test code and simplifying my DB design. :(
KISS is always the best choice. Someone else will inderstand it better when reading, updates are easier and less complicated, and less code in general means fewer bugs. I'll give you a ping when I'm done and posted it :)
Bastard Programmer from Hell :suss: If you can't read my code, try converting it here[^]
-
I don't care for patterns in my code and I definitely don't care for vague terms like "clean" code. I only care for code that's short, safe to fail, easy to test, and understandable by a college freshman in less than 2 weeks. Nevertheless, please write about the patterns you think are worthwhile; preferably with a not-too-generic example. You might teach us something worthwhile. Also, if anyone knows of a must-read regarding the use of factory-pattern, please share. I really hate it and I'm looking for material to nuance my feelings towards it.
