Design and Architecture

Member 10508854 wrote:

Take this topic as a brainstorm topic to get the best ideas.

comiscience wrote:

Unify naming convention.

comiscience wrote:

Unify comment humain language

comiscience wrote:

Version control of third party libaries.

comiscience wrote:

Length of Method.

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

comiscience wrote:

But how could you read other's code which has 100 lines more in a method?

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

// -------- Ordinary class
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()
    {
        // Calling the base class GetInfo method:
        base.GetInfo();
        Console.WriteLine("Specimen ID: {0}", id);
    }
}

// -------abstract class
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()
    {
        // Calling the base class GetInfo method:
        Console.WriteLine("Name2: {0}", name2);
        Console.WriteLine("SSN2: {0}", ssn2);
        Console.WriteLine("Specimen ID: {0}", id);
    }
}

public class implementation
{
 // the constructor
 public implementation()
 {
// This is base class access of the getinfo() method
   Seagull1 E = new Seagull1();
   E.GetInfo();

// The following is abstract class access of the getinfo() method
   Seagull2 A = new Seagull2();
   A.GetInfo();
 }
}

Quote:

Name1: Poultry
SSN1: Mostly flying creatures
Specimen ID: ABC567EFG
Name2: Poultry
SSN2: Mostly flying creatures
Specimen ID: ABC567EFG

netfed wrote:

C#

public virtual void GetInfo()
{
  Console.WriteLine("Name1: {0}", name1);
  Console.WriteLine("SSN1: {0}", ssn1);
}

Quote:

A class that inherits from an abstract class cannot access the original implementation of a method

public class D
{
    public virtual void DoWork(int i)
    {
        // Original implementation.
    }
}

public abstract class E : D
{
    public abstract override void DoWork(int i);
}

public class F : E
{
    public override void DoWork(int i)
    {
        // New implementation.
    }
}

netfed wrote:

abstract classes without any implementations just look like Interfaces

netfed wrote:

A class that inherits from an abstract class cannot access the original implementation of a method

abstract class A
{
  // 2) A doesn't store the label content - a derived must
  abstract string Label {get;};

  string ToLabel()
  {
    // 1) Implementation centralized - not in all derived classes
    return this.Label;
  }

  // 3) implementation that can be extended or even replaced
  virtual void Writeline()
  {
    Console.Out.Writeline();
  }
}

class X : A
{
  // 2) A says I must do this - I at least choose the content
  override string Label{ get{ return "I am X!"; }}
  
}

class Y : A
{
  // 2) A says I must do this - I at least choose the content
  override string Label{ get{ return "Me is Y!"; }}

  // 3) optionally extending implementation in abstract class
  override void Writeline()
  {
     Console.Out.Writeline(">>>"); // extra before base
     base.Writeline();
     Console.Out.Writeline("<<<"); // extra after base
  }
}

void SomeCode()
{
  // 4) Polymorphism - declaring a collection of abstract classes but adding instances of derived classes
  List<A> as = new List<A>();
  as.Add(new X());
  as.Add(new Y());
  foreach(A a in as) // 4 - accessing abstract implementation
  {
    Console.Out.Writeline(a.ToLabel); // 4 - no branching on implementation e.g. typeof(X) or typeof(Y)
  }
}