class-design

How to design classes involving collections of other classes? General Example: A Workspace contains number of Projects . A Project contains large number of Resources . Each Resource may contain large number of Files . So here the classes identified can be Workspace,Project,Resource and File. Workspace will have list of Project.Project will have list of Resources and Resource will have list of Files. Of course each class has its related settings. Now the basic questions are : a) Who creates and adds a class to a particular collection? Another class or the class containing the collection? b)

I am just getting started with .NET ORMs, to the point where I haven't even decided between Entity Framework and NHibernate. But in both cases, I'm running into a problem in that they seem to want me to compromise the integrity of my domain model in various ways, especially on finer points of C# object design. This is one of several questions on the subject. I am very used to enforcing immutability on appropriate properties with a pattern that looks like this: public class Foo { private readonly string bar; public string Bar { return this.bar; } public Foo(string bar) { this.bar = bar; } }

One thing I've run into a few times is a service class (like a JBoss service) that has gotten overly large due to helper inner classes. I've yet to find a good way to break the class out. These helpers are usually threads. Here's an example: /** Asset service keeps track of the metadata about assets that live on other * systems. Complications include the fact the assets have a lifecycle and their * physical representation lives on other systems that have to be polled to find * out if the Asset is still there. */ public class AssetService { //...various private variables //...various methods

The following code in javascript gives me the error "this.callback is not a function function ajaxRequest() { var httpObject; this.open = open; this.callback = function(){}; function getHTTPObject() { if (window.ActiveXObject) return new ActiveXObject("Microsoft.XMLHTTP"); else if (window.XMLHttpRequest) return new XMLHttpRequest(); else { alert("Your browser does not support AJAX."); return null; } } function onstatechange() { if(httpObject.readyState == 4) { this.callback(httpObject.responseText); } } function open(url, callback) { httpObject = getHTTPObject(); if (httpObject != null) {

Immutable classes are great but there is one big problem i cant think of a sensible way to solve - cycles. class Friend { Set<Friend> friends(); } How does one model Me having You as a friend who in turn has me as a Friend back ? IMMUTABILITY This class from the outside world should definitely be immutable. The value held internally should be constant for the purposes of equality checks. [[[ Edit: Added code to demonstrate fully immutable concept ]]] That's why builders are so nice for immutables - they allow mutability during construction to get everything set before you "freeze" it. In this

In this thread I found some interesting moment, If class uses only as superclass there isn't rule to make it abstract. Why so? Thanks It all depends on whether or not it makes sense to have instances of the class . Suppose you for instance have one class Dog and one class Cat . They both extend Animal . Now an Animal may have a name and a few methods, but it doesn't make sense to have Animal s running around. An Animal is... well an abstract notion. In other circumstances you may have subclasses (the LinkedHashSet for instance extends HashSet ) but it still makes a lot of sense to instantiate