|
AikinX wrote: Am I right?
Your statements are to specific.
Stateless[^]
In computer science, stateless refers to a system or protocol which does not keep a persistent state between transactions.
led mike
|
|
|
|
|
Yes, I saw this definition, but it told me nothing else
|
|
|
|
|
AikinX wrote: but it told me nothing else
There is nothing else to your question. Each server is different but Stateless means Stateless, period.
led mike
|
|
|
|
|
I re-read the definition and found that this one is a definition for stateless, not for stateless server. I didn't saw that before. It is a very useful one. Thanks.
But I don't think it is fully related to a "stateless server", because the one doesn't have it's own "persistent state". A server is a container for applications that are ran into the one. So It can only provide underlying applications with a more usable request to clients.
Yes, it can store some information, but not for itself -- for it's applications.
So, I think is better to use it's own definition: a stateless server[^]
A stateless server is a server that treats each request as an independent transaction that is unrelated to any previous request.
Although this definition is very useful to understand next ones: a stateless application, a stateless session, ...
Thanks again, led mike.
|
|
|
|
|
AikinX wrote: But I don't think it is fully related to a "stateless server"
It is definitely fully related. In the context of "a server" the definition of "stateless" does NOT change.
AikinX wrote: A server is a container for applications that are ran into the one.
No. It can be but the word "server" is not limited to that. In client-server architecture "server" refers to the process that services the clients. However there is a non client-server architecture use of a server process that may not service clients at all. It may not receive requests of any kind.
led mike
|
|
|
|
|
Stop, I've just realized. The Google seacher is not a server. It is an application running into the server
No, more questions, thanks.
|
|
|
|
|
In a helper class, I have a dictionary (object, target), where target can be created in a very few different ways, e.g. a delegate, a type or a specific object.
Specifying a System.Type for target will be the most common option, but the caller should be able to use a custom delegate as well.
One way to implement this is an abstract base:
class TargetBase
{
abstract object Convert(object o);
};
public class TypeAdapter
{
Dictionary<object, TargetBase> dict;
public void Add(Type source, Type target) { dict.Add(source, new TypeTarget(target); }
public void Add(Type source, MyDelegate target) { dict.Add(source, new DelegateTarget(target); }
object Map(object o) { return dict[o.GetType()].Convert(o); }
};
(I've omitted the Typetarget, DelegateTarget implementations for brevity)
Alternatively, since a delegate is in there anyway, I could use the delegate for the other options:
public class TypeAdapter
{
Dictionary<object, MyDelegate> dict;
public void Add(Type source, MyDelegate target) { dict.Add(source, new DelegateTarget(target); }
public void Add(Type source, Type target)
{
dict.Add(source, delegate(object o) { Activator.CreateInstance(target, o); }
}
object Map(object o) { return dict[o.GetType()](o); }
};
The current implementation uses struct containing either a delegate or a type, and acts depending on which one is not null. This is IMO quite ok, since there is only a minor chance of a 3rd option, and I can't conceive more.
I'd like to get some feedback which way you would go, and why. Topics I see are readability/maintainability and performance*
*) I claim "not a premature optimization" here, since it's intended as a library component I don't know how it will be used, and I have no feeling for the performance/overhead of virtual calls vs. delegates.
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
|
|
|
|
|
peterchen wrote: In a helper class
I see this "helper class" statement being used a lot recently. At first I wonder, did I skipped the chapter in Design Patterns[^] that discusses the Helper Class Pattern? Then I remember that I'm seeing it here on code project and realize that it is more likely a result of poor design.
If I am wrong help me pleeeezzz, it's urgent
led mike
|
|
|
|
|
Maybe it's not a very good label, would "utility class" be a better one?
I put everything under that label that is not explicitely domain-specific, i.e. doesn't have a roöe specific for the actual project at hand. Nonetheless, it has a very distinct role.
We could also call it "glue and plaster". The idea I am following might be in very thin air[^], I will see.
Maybe I should just have written "In a class"
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
|
|
|
|
|
peterchen wrote: Maybe it's not a very good label, would "utility class" be a better one?
No. Unless I also skipped the Utility Class Pattern chapter in Design Patterns as well. Keep in mind I don't really care what all you guys do in your projects, but when you post a question in the "Design" forum it seems appropriate to mention that you may not be following the principles of Object Oriented Design and the use of Design Patterns.
peterchen wrote: The idea I am following might be in very thin air[^], I will see.
When you go too far up, abstraction-wise, you run out of oxygen.
That doesn't seem to match what you posted because what you posted sounds like it fits a Creational Pattern[^]
led mike
|
|
|
|
|
phuket, CP ate my reply
led mike wrote: Unless I also skipped the Utility Class Pattern chapter in Design Patterns as well
Are you sure you are not mixing up "Design Patterns" with "Compendium of past, current and future entity classification systems"? They like, have the same cover color and stuff
I'm not looking for a creator as such - I don't have a clear picture yet myself, so I tried to avoid the underlying problem.
If you require the same interface from diverse types, you will have some that implement (i.e. know) the interface, and others for which you need a proxy (adapter? surrogate? your call! ). What I am throwing some brain cycles at is a kind of as operator where you can register a surrogate for certain types.
A similar pattern is used in serialization, where you can register surrogates for certain types that need specific handling.
Another thing (the one I'm actually coming from) is MVC for "aggregate" views (like lists, trees, grids etc.) Here, the surrogate could acts as a "node controller" for diverse data node classes.
I'm not yet sure if this makes sense, but also that was not my question
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
|
|
|
|
|
Yeah, I see someone liked your reply enough to vote it a 5. All that stuff you said is great but where in surrogates and aggregate views and interfaces and all those nice buzz words you used is a "Helper" class? I don't think so.
led mike
|
|
|
|
|
I showed you my definition of a "Helper class" (everything outside being domain specifc), now show me yours!
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
|
|
|
|
|
|
Hmm... strange - I've been to Bolivia, but I've never seen anyone call these monkeys "helper class" over there
Seriously:
Of course, if "helper classes" don't exist for you (because it's not a very descriptive term, or the GOF haven't written about it, or for whatever reason), this whole discussion is pointless.
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
modified on Thursday, May 15, 2008 5:20 PM
|
|
|
|
|
I'd say go for the first approach.
By using your "TargetBase" class (or ITarget iface), you can apply extra information on those instances later on if you need.
Eg,
ITarget dt = new DelegateTarget(target);
dt.Status = TargetStatus.New; // Im not saying that these properties applies in this context
dt.TimeToLive = 123; //just that you have the option to add extra info if you need
dict.add(source, dt);
By using the pure delegate approach you can never attach any metadata to your targets.
Except for using more dictionaries that carry the extra info for each delegate.
Maybe you don't need such features, but IMO: an interface approach is always easier to extend than a pure delegate approach.
And I think an interface approach is cleaner when it comes to semantics (this is ofcourse just my own take on it, others may not agree)
Eg, every class that implements "ITarget" (or inherits TargetBase) promises that its purpose is to do what the interface implies.
(ofcourse you can abuse it and implement it differently, but the semantics associated with your interface promises something)
While delegates are more "oh yeah, I just return something of the correct type" , there is not the same kind of promise attached to a delegate type.
modified on Thursday, May 15, 2008 7:24 AM
|
|
|
|
|
My debugger breaks for the below exception when trying to restore a database, because the database is in use. My question is, if I don't catch exceptions in my DatabaseHelper class, following what I believe to be good practice, then I should at least catch and publish the exception in clients of DatabaseHelper . However, these clients should know nothing of this FailedOperationException exception, so to catch it I would have to broaden my catch scope, which I believe is not good practice. What do I do?
Microsoft.SqlServer.Management.Smo.SmoExceptionType.FailedOperationException
|
|
|
|
|
You catch this in your database class. This is a specific database related problem - I would then throw this as a custom exception to the client applications, with details of this as the inner exception.
|
|
|
|
|
This is for a testing framework, so would you minimise custom exceptions and use one for multiple helper classes, or go with a tighter fit of one custom exception per helper class?
Also, I use DatabaseHelper in SelectionHelper, so using only one custom exception reduces the complexity of Russian Doll type exceptions. In SelectionHelper I wrap CLR exceptions, and just re-throw custom exceptions.
|
|
|
|
|
We tend to use exceptions based on logical areas.
|
|
|
|
|
I am busy with a new ConfigHelper class, and can't seem to decide on which approach to take. The class is responsible for adjusting the config table in two databases, control and test. My dilemma is whether I make ConfigHelper a static class, and tell it which database to access for each task, or use instance methods and have one instance for each database.
|
|
|
|
|
Out of the blue, use instances and specify table identification in constructor.
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
|
|
|
|
|
I face similar issues all the time and I've come to the conclusion that whenever this dillema comes up to always choose static. I've never regretted it.
"The great pleasure in life is doing what people say you cannot do."
- Walter Bagehot
|
|
|
|
|
Evolution of the project has driven me to instance methods. This enables injecting specific helper class instances as dependencies into larger composite objects with more task oriented sets of responsibilities, such as running an integration test. E.g. I have two ExportTest derived classes, one that produces the control output, and another that produces the test output, with very different implementations. However, the base ExportTest class provides all derived classes with a DatabaseHelper object built by a factory according to their needs.
Semicolons. the number one seller of ostomy bags world wide. - dan neely
|
|
|
|
|
Is it going to be something that like the .NET configuration classes is going to be a "quick and simple" solution so to speak, and are users / programmers going to have to access the methods quickly? If that's the case I'd lean towards a static approach.
If it's going deeper and more involved (i.e. more extensible) and likely to be in the foundations of the project so to speak then I'd go for instance methods because you can set them up and customise them and then everything on top accesses that.
If that made any sense at all?
I doubt it. If it isn't intuitive then we need to fix it. - Chris Maunder
|
|
|
|
|