|
Hi Kim,
It is a bit difficult to give you some concrete advice, but here are my thoughts. I think they are classic 3 tier'ish.
The easiest is the lower layer aka the data layer e.g. a simple API that stores data types in a storage (memory, disk, db, whatnot). This can certainly be within its own project (with its own unit tests) - it doesn't need commands or similar. For abstract data classes, etc. I prob. would make a "Core" namespace within this project.
Another easy layer is the top layer aka the UI layer. Whether or not you tie the Application together with the UI layer in 1 assembly/package is a flexibility matter. In any case I would probably make a "Core" namespace within this layer too, but it has nothing to do with the data layer classes - only the UI.
The hardest part is how you design control from the top layer to the data layer and how the top layer is updated indirectly by updates in the data layer. In MVC its the C, in SOA it is the services. I would create a middle layer aka the service layer that knows the data layer, but doesn't know the UI layer. In here you can make a lot of Controllers e.g. Commands that modifies the data layer. If you have a pull design, you can make some poll/query commands too. If you have a push design, you can register a general listener pattern that the UI layer can use, or fire commands going upwards to be consumed by the UI layer (not so popular in these client-server days). This middle layer also will have its own "Core" namespace with abstract Commands and whatnot.
In above way you have a very clean division. It is pretty simple to avoid dependencies from the data layer to others, and it is doable to avoid a dependency from the control layer to the UI layer. One thing to consider is, if the UI layer should have direct access to the data layer. I find this decision hard to make - many cons and pros.
If it makes sense for you to have a common assembly then go make that and let the 3 layers depend on that. Otherwise, just pull in logging, etc. in each layer. A common layer can easily mud your clean dependencies; before you know it there is a utility class that knows how to calculate some business data and it is used by both the UI and the Data layer.
I hope it makes sense and triggered some thoughts.
Kind Regards,
Keld Ølykke
|
|
|
|
|
I'm not a project manager, i'm just a developper. But i wanna know yours opinion for coding together in a team. Here will listes my coding habits which i think is good. This article is partially on the opposite of another article of mine "Several Easy WPF Teamwork Tricks"
Unify naming convention. We'll encounter some Here is a paragraphe of the reply of a friendly member of CodeProject :
While some people may not like switching coding styles, it does not take very long to get used to coding a different way. There is a huge benefit to having a standard coding style. On my development team, we adhere to a somewhat strict coding style. It doesn't matter what file you look at, it is written the same as every other one. It is very easy to read other peoples code since it looks like your own. I know immediately when I look at an identifier whether it is a member field, public property, or local variable without having to go search for where it is defined. If I did have to search for where it is, it would be in the same spot in the file as it is in every other file because there is a standard.
Unify comment humain language. I'm a Asian guy who lives in France. My main language is not french nor english. But i read only English technical books and i speak French everyday. It's sure that i don't write Chinese in my project because all my other collegues won't understand it. But should we comment with English ? Or French (Native humain language) ? One point i'm sure is that comment with both English and French could be a very terrible thing. (At least, it makes me very angry sometimes).
Version control of third party libaries. I use DevExpress, mysql and so on in my project. I'd like to update them once they published their new version. It cause sometimes a very big change in my project. But i'd prefer to update it all the time. Because we can track its changes without missing some important things. But if work with team? I think we should negociate it. I prefered to suggest them to update versions frequently. Because we can always keep the same version for the same project. I know it cause us lot of work in every update.
Length of Method. I don't like methods which contains more than 30 lines. It makes code urgly. It's my style. Because i found that it's more clear when we read method with less than 30 lines. We could find the function module quickly. We watch a function module with F12 instead of scroll our mouse. Method's name could also be used as a comment. It sometimes forced us to write more reusable methods.
public void RunSome()
{
try
{
if (!PrepareEngin()) throw new Exception("No usable engin");
if (DoWeHaveAnCat())
{
PlayWithCat();
}
else if (GoToBuyAnCat())
{
RunSome();
}
}
catch (Exception exp)
{
throw exp;
}
}
private bool PrepareEngin()
{
return true;
}
private bool DoWeHaveAnCat()
{
return true;
}
private void PlayWithCat()
{
}
private bool GoToBuyAnCat()
{
return true;
}
Don't have too many empty line in a method. It wastes my time to read it and positionning!
A teamwork should be harder than a solo work. I'll work with a team in 2014. I'm not project manager, but i wish we'll have a good 2014
History
An opposite article of mine ("Several Easy WPF Teamwork Tricks") was criticized by members. I'accept that it wasn't a good article. But it's also an other way of thinking.
modified 7-Jan-14 2:21am.
|
|
|
|
|
comiscience wrote: Unify naming convention. Guidelines for Names, .NET Framework 4[^]
comiscience wrote: Unify comment humain language English.
comiscience wrote: Version control of third party libaries. Yes.
comiscience wrote: Length of Method. The compiler does not care about ugly, I not about your style. If it breaks the single-responsibility principle, it's probably a candidate for refactoring.
Bastard Programmer from Hell
If you can't read my code, try converting it here[^]
|
|
|
|
|
Hi, thanks for your suggestion
But how could you read other's code which has 100 lines more in a method? It wasted me lot of time to scroll and positionning..
|
|
|
|
|
comiscience wrote: But how could you read other's code which has 100 lines more in a method? With a sad face.
Then I'd refactor the code, and ask the other if the change is acceptable. The compiler doesn't care about the length, nor do I - but I do care about readability and maintainability. Code that's complex is harder to support, so one would strive to keep it as simple as possible (one responsibility!)
Sit down with the other, and take the time to make it more readable; it'll help the other with writing better code, will lower your frustration-level, and will lower the cost to support the code, since simpeler code contains less bugs. Demanding that a method has a maximum length of, say, 10 lines would simply mean that coders start to divide that code over multiple methods that get called consecutively. You'd end up with the same code, but now divided over multiple methods.
Bastard Programmer from Hell
If you can't read my code, try converting it here[^]
|
|
|
|
|
Thanks Eddy
|
|
|
|
|
Install StyleCop across the team, and adjust its rules to suit the team. Then make sure that people review the output - I find that running it as part of the CI process is a great way to pick things up, plus it could form of your code review checklist. I'm pleased to see that you dropped your stance on not commenting - meaningful and well maintained comments are an absolute must.
|
|
|
|
|
|
Refering to the following two pair of classes:
public class Person
{
protected string ssn = "444-55-6666";
protected string name = "John L. Malgraine";
public virtual void GetInfo()
{
Console.WriteLine("Name: {0}", name);
Console.WriteLine("SSN: {0}", ssn);
}
}
class Employee : Person
{
public string id = "ABC567EFG";
public override void GetInfo()
{
base.GetInfo();
Console.WriteLine("Employee ID: {0}", id);
}
}
public abstract class animal
{
protected string ssn = "Poultry";
protected string name = "Mostly flying creatures";
public abstract void GetInfo();
}
class Seagull : animal
{
public string id = "ABC567EFG";
public override void GetInfo()
{
Console.WriteLine("Name: {0}", name);
Console.WriteLine("SSN: {0}", ssn);
Console.WriteLine("Specimen ID: {0}", id);
}
}
Implementing them:
Public class A2Implementation {
public A2Implementation()
{
Employee E = new Employee();
E.GetInfo();
Seagull A = new Seagull();
A.GetInfo();
}
Question
I get the exact same result in the implementation of the two pairs (unclear, albeit intentionally).
Now what are the pros and cons of using an abstract definition here (the animal-Seagull track), or what is best; just using ordinary base class Access (the Person-Employee track)?
Could I be mistaken in assuming that there is a concordance here.
modified 5-Jan-14 4:48am.
|
|
|
|
|
Not sure what you try to achieve, but from the example you made it's clear that the base-class approach is better for you.
When using abstract class you was unable to put Name and SSN into the abstract (no room for this), but if these properties are common to all then it's much better to put it in some base (that's why it called base!)...
|
|
|
|
|
Alright. I've managed to cram it in there, the abstract Properties, and I've changed the Whole lot to look a lot more similar With regards to content. Now here is what I got:
public class animal1
{
protected string name1 = "Poultry";
protected string ssn1 = "Mostly flying creatures";
public virtual void GetInfo()
{
Console.WriteLine("Name1: {0}", name1);
Console.WriteLine("SSN1: {0}", ssn1);
}
}
class Seagull1 : animal1
{
public string id = "ABC567EFG";
public override void GetInfo()
{
base.GetInfo();
Console.WriteLine("Specimen ID: {0}", id);
}
}
public abstract class animal2
{
public abstract string name2 { get; }
public abstract string ssn2 { get; }
public abstract void GetInfo();
}
class Seagull2 : animal2
{
public string id = "ABC567EFG";
public override string ssn2
{
get { return "Mostly flying creatures"; }
}
public override string name2
{
get { return "Poultry"; }
}
public override void GetInfo()
{
Console.WriteLine("Name2: {0}", name2);
Console.WriteLine("SSN2: {0}", ssn2);
Console.WriteLine("Specimen ID: {0}", id);
}
}
The implementation and output follows:
public class implementation
{
public implementation()
{
Seagull1 E = new Seagull1();
E.GetInfo();
Seagull2 A = new Seagull2();
A.GetInfo();
}
}
Resulting text output:
Quote: Name1: Poultry
SSN1: Mostly flying creatures
Specimen ID: ABC567EFG
Name2: Poultry
SSN2: Mostly flying creatures
Specimen ID: ABC567EFG
It seems to me that the use of abstract classes in this case is redundant, and the first track is sufficient, let alone more efficient. I am wondering then when the abstract classes kicks in with their possible advantages?
Could it be, if I introduced the Penguin which is not able to fly, that the flyingability becomes an issue urging the use of abstract classes?
modified 5-Jan-14 9:18am.
|
|
|
|
|
It get me back exactly to the same point...
netfed wrote:
public virtual void GetInfo()
{
Console.WriteLine("Name1: {0}", name1);
Console.WriteLine("SSN1: {0}", ssn1);
}
This code is common to all classes based on animal1 , you never write it again.
In the abstract version you have an empty GetInfo method (it's abstract so it must be empty!), and in every instance inherits this abstract class you must implement Name and SSN ...
You see base classes used when you have a certain amount of common functionality that known. Abstract class are more like interfaces as they declare the structure of the class inherits them, with the addition of some common functionality...
Again - based on your sample base class is better for you...
|
|
|
|
|
Abstract class provides you with an option to declare a non-instantiable base class from which your concrete classes inherit. You cannot instantiate an abstract class, you must instantiate one of your concrete classes.
But if you wish to be able to instantiate the base class, then do not declare it abstract. If there is shared logic that can be generalized, use an abstract base class. If the base set of functionality is complete on its own, then you can use a concrete base class.
|
|
|
|
|
Well yes. But what would be really cool is, if someone would be willing to take the time, to suggest a new code block, which could show where the abstract track is better. Anyone?
|
|
|
|
|
There are plenty of example explanations of this all over the internet.
Veni, vidi, abiit domum
|
|
|
|
|
This[^] article might help you.
|
|
|
|
|
Thanks for that link. The article showed some variation there in the end, that brought in some ideas on how abstract classes could be useful (the IEnumerable). I think I will play With several code blocks and compare the use of them. I will read some books on the subject.
I can also now can conclude on of my problems:
- abstract classes without any implementations just look like Interfaces
- It seems to me that using abstract classes in a small context is shear silliness, but in a larger "code-stretch" they are beneficial, as my second code post and it's answer shows.
- A class that inherits from an abstract class cannot access the original implementation of a method
modified 12-Jan-14 7:29am.
|
|
|
|
|
Quote: A class that inherits from an abstract class cannot access the original implementation of a method
Actually it can, just call base .MethodName(...) to call the base implementation, even if you have overridden it. Works for overridden properties too.
|
|
|
|
|
public class D
{
public virtual void DoWork(int i)
{
}
}
public abstract class E : D
{
public abstract override void DoWork(int i);
}
public class F : E
{
public override void DoWork(int i)
{
}
}
You can't call DoWork in class D from F. Which brought me to a new reason for using abstract classes: an abstract class can force derived classes to provide new method implementations for virtual methods.
|
|
|
|
|
Yes, that's right, you can't call the base.base method since F overrides E not D.
But I wouldn't agree that a base class can force its derived classes to provide a new method using virtual, since E has the choice to provide a new method or force it to the derived class. This is the function of the abstract operator, not the virtual one. The only reason that DoWork was forced to be overridden is because its base class (E) declared it as abstract, not because D declared it as virtual. In this instance E is the base class, not D, so it forces through the abstract keyword, not the virtual one.
|
|
|
|
|
netfed wrote: abstract classes without any implementations just look like Interfaces More or less Yes, but their purpose are different. Interface is used to enforce a contract while Abstract class is used to build family trees.
netfed wrote: A class that inherits from an abstract class cannot access the original implementation of a method As the reply below already suggests, use base.MethodName() syntax.
|
|
|
|
|
Hi,
1) With an abstract class A you can define re-usable implementation for derived classes. This is a way of removing duplicate code in multiple derived classes.
2) With an abstract class you can defer implementation to derived classes e.g. defining abtract methods or properties. Why would you do that? Well you can call the abtract definition from implementation in the abstract class.
3) With an abstract class you can let implementation code be extended via overrides
4) With an abstract class you can declare collections of the abstract class, but add derived classes to the collection.
I will try to make an example to illustrate above features:
abstract class A
{
abstract string Label {get;};
string ToLabel()
{
return this.Label;
}
virtual void Writeline()
{
Console.Out.Writeline();
}
}
class X : A
{
override string Label{ get{ return "I am X!"; }}
}
class Y : A
{
override string Label{ get{ return "Me is Y!"; }}
override void Writeline()
{
Console.Out.Writeline(">>>");
base.Writeline();
Console.Out.Writeline("<<<");
}
}
void SomeCode()
{
List<A> as = new List<A>();
as.Add(new X());
as.Add(new Y());
foreach(A a in as)
{
Console.Out.Writeline(a.ToLabel);
}
}
Lots of patterns make use of abstract classes e.g. http://en.wikipedia.org/wiki/Abstract_factory_pattern[^] and http://en.wikipedia.org/wiki/Composite_pattern[^].
Try play around with it and the different ways of calling up or down between abstract and concrete classes. It takes some getting used to and some redesign.
Some rules I try to stick to stay sane:
- (abstract class) only declare fields as private
- (abstract class) store a field for each non-abstract property (if a state)
- (abstract class) use protected properties/methods to serve derived classes (hidden from the public)
- (abstract class) always expect virtual methods/properties to be called by derived classes
- (derived class) always call base in overriden virtual method/property
I hope it helps.
Kind Regards,
Keld Ølykke
|
|
|
|
|
Thank you for the code, although it had to be modified a bit to run, but what do you mean by the following:
- (derived class) always call base in overriden virtual method/property?
This I do get, and I find it a good OO-realted advice:
(abstract class) only declare fields as private.
Thanks for the link that lead to this:
[^]
... which talks about the usefulness of it all.
modified 12-Jan-14 7:43am.
|
|
|
|
|
Hi,
You are welcome. Maybe you should post the runnable code, if you think it will help people.
"but what do you mean by the following:
- (derived class) always call base in overriden virtual method/property?"
Inheritance in OOP is relatively loose. The only thing you can be certain about is that constructors are chained e.g. new Y() will call the constructor of Y that as its first statement will call the constructor of A, etc.... all the way up til the contructor of Object. You can then have your constructor code in different implementation called on the way back from Object.
For all other methods/properties no such guarantee exists. In other words it is optional to call a base-method, which makes it pretty hard to manage private fields in the base class
So these 2 go together:
-----------------
- (abstract class) always expect virtual methods/properties to be called by derived classes
- (derived class) always call base in overriden virtual method/property
-----------------
It is just 2 calling convention rules that mimic the constructor chaining for all virtual methods. In this way we can design interdependency between A and X - even though the language supports that you can avoid calling base methods/properties.
I hope it makes sense... otherwise I can elaborate.
Thx for the nice link, btw.
Kind Regards,
Keld Ølykke
|
|
|
|
|
Hi Community. I have some questions about Loose Coupling Pattern in the Application Design. Is Loose Coupling Pattern The Best pattern for a TDD (Test Driven Development). Can you tell other Patterns in Application Design for TDD? Please can you bring some examples about Loose Coupling?
modified 8-May-21 21:01pm.
|
|
|
|
|