software-design

I have seen a number of DDD posts and indeed books where entity classes are derived from some form of base class that has a generic parameter for the Entity Identity type: public interface IEntity<out TKey> { TKey Id { get; } } public interface IComplexEntity<out TKey, in TEntity> { TKey Id { get; } bool IsSameAs(TEntity entity); } //Object Definition public class TaxPayer : IComplexEntity<string, User> { ... } On Vernon's Implementing Domain Driven design, specific types are created for use as identities: public class TaxPayerIdentity : Identity { public TaxPayerIdentity() { } public

I am writing a simulation of Bananagrams. Currently, I have a GameMaster class that maintains the common collection of pieces. The deal(Player) method deals a certain number of pieces to that player. I want to write unit tests for this. However, at this point, I have no getters, and thus no way to check the status of the objects. Why not add getters? I don't want to add code to the public interface only for testing. Right now, there is no other reason to expose those functions. What am I supposed to do here? Add the getters anyway, cluttering the public API (or hoping that they will be needed

I am learning design patterns newly & I am trying to understand the difference between Simple Factory & Factory Method Pattern. First I want to clear that , I tried reading lot of articles from Stack-overflow and other sites regarding the same but that doesn't helped me. Here is my question: Lets consider I have a product hierarchy as shown below: I have written a simple Factory class as shown below public class SimpleItemFactory { static Item getItem(String type) { if(type.equals("Cake")) { return new Cake(); }else if(type.equals("Chocolate")) { return new Chocolate(); }else { return null; }

Closed . This question is opinion-based . It is not currently accepting answers. Want to improve this question? Update the question so it can be answered with facts and citations by editing this post . Closed 2 years ago . Contextualisation Im am implementing a bytecode instrumenter using the soot framework in a testing context and I want to know which design is better. I am building the TraceMethod object for every Method in a Class that I am instrumenting and I want to run this instrumenter on multiple Classes. Which Option offers more performance(Space–time)? Option 1: (Maps) public class

I work with Spring Data and Neo4j in my current project and have the following situation: @RestController @RequestMapping(value = SearchResource.URI) public class PersonResource { public static final String URI = "/person"; @Autowired PersonRepository personRepository; @GetMapping public Collection<Person> findPersons( @RequestParam(value = "name", required = false) String name, @RequestParam(value = "birthDate", required = false) Long birthDate, @RequestParam(value = "town", required = false) Spring town) { Collection<Person> persons; if (name != null && birthDate == null && town == null) {

There is this codebase where we use automapper and have 2 layers, Domain and Service . Each has its object for data representation, DomainItem and ServiceItem . The service gets data from domain, the uses constructor injected automapper instance to map class Service { public ServiceItem Get(int id) { var domainItem = this.domain.Get(id); return this.mapper.Map<DomainItem, ServiceItem>(domainItem); } } Assume best practices, so mapper has no side-effects and no external dependencies. You'd write a static function to convert one object to another within seconds, just mapping fields. With this in