Ggtcf

building using Webforms

I have a number of classes they contain all sorts of properties:

Lets say:

USER:
Forename,
Surname,
EyeColour,
FavouriteIceCream

In different parts of my site I need to display a list of users thus:

Bob Jones,
Fred Smith,
Susan Gifford

whereas in other parts I need a list:

GIFFORD, Susan
JONES, Bob
SMITH, Fred

Like wise I might need to abbreviate their names to

BJo
FSm
SGi

In my head it seems sensible to have additional properties inside my class called:

Fullname (forename + ' ' + surname)
Reverse (ToUpper(surname) +', ' + forename)
Intials

which are filled at time of creating the USER object and so later when I want to display Bob I can call
ThisUser.FullName rather than

ThisUser.Forename + " " + ThisUser.Surname

Is it bad practice to be creating extra properties at time of creation if I'm not going to be using them often?

Obviously I've simplified here but is it bad to have the FavouriteIceCream field being substantiated every time I refer to a User even if I only use their favourite flavour on a page viewed infrequently.

To me it seems a good way to be consistent, any page that wants to use the reverse format of a name is always going to be JONES, Bob rather than sometimes Jones, Bob if the page is written by one of the team who has forgotten the format required
The other side of the argument I guess would that we have a bare minimum user class and we pull in the extra fields only when we need to know their dairy preferences

//additional,
if it makes a difference, internal intranet based webform so only 200 users

Is it bad practice to be creating extra properties at time of creation if I'm not going to be using them often?

Yes. Use read-only calculated properties:

public String Fullname 
 get 
 return Forename + " " + LastName;
 

I think that storing these properties’ values at the time the instance is created is a bad idea. But you still can use properties getters like this:

string Forename;
string Surname;

// set value for the private properties as usual
public User(string fn, string sn)

 Forename = fn;
 Surname = sn;


// getters
public string DefaultName

 get return Forname + “ “ + Surname; 


public string ReversedName

 get return Surname + “ “ + Forename; 

without taking extra space in memory for data that you just can manipulate at runtime. Otherwise, you can created methods for getting manipulated name, as the other answer suggested. Anyways, never storing redundant data is always best

which are filled at time of creating the USER object [...] have the field being substantiated every time I refer to a User...

Are you talking about creating static properties that you would populate? Why not just create dynamic properties? Something like this:

public string Fullname get return $"Forename Surname"; 
public string Reverse get return $"Surname.ToUpper(), Forename"; 
// etc.

There's no need to populate the same data twice, and these won't be used until you call them.

Basically it's not a choice between duplicating data vs. putting the logic all over the application, it's a choice between putting the logic all over the application or putting it on the object. Just put the logic on the object.

As usual: it depends.

Filling a bunch of properties of a class to hold various versions of the same informations is IMHO not the best idea.

Depending on how complex this creating is and on how many places it will be used, this could be either just an extension method, a private method within the view that needs that specific kind of view or a direct property of the class itself.

By using a property of the class itself you have at least four possibilities:

• 
  

  Fill up while creating the object (if it is immutable)

  
  
  

  public class Person
  
   public Person(string firstName, string lastName)
   
   FirstName = firstName;
   LastName = lastName;
   FullName = $"FirstName LastName";
   
  
   public string FirstName get; 
   public string LastName get; 
   public string FullName get; 
  
  

  
  


• 
  

  Fill it up when the depending setter was called (if it is mutable)

  
  
  

  public class Person
  
   private string _firstName;
   private string _lastName;
  
   public string FirstName
   
   get => _firstName;
   set
   
   _firstName = value;
   UpdateFullName();
   
   
   public string LastName
   
   get => _lastName;
   set
   
   _lastName = value;
   UpdateFullName();
   
   
   public string FullName get; private set; 
  
   private void UpdateFullName()
   
   FullName = $"FirstName LastName";
   
  
  

  
  


• 
  

  Create the value on the fly whenever it will be called (multiple times if called multiple times)

  
  
  

  public class Person
  
   public string FirstName get; set; 
   public string LastName get; set; 
   public string FullName => $"FirstName LastName";
  
  

  
  


• 
  

  Create the value once when it is called and return this result until the depending value has been changed.

  
  
  

  public class Person
  
   private string _firstName;
   private string _lastName;
   private Lazy<string> _fullName;
  
   public string FirstName
   
   get => _firstName;
   set
   
   _firstName = value;
   UpdateFullName();
   
   
   public string LastName
   
   get => _lastName;
   set
   
   _lastName = value;
   UpdateFullName();
   
   
   public string FullName => _fullName.Value;
  
   private void UpdateFullName()
   
   _fullName = new Lazy<string>(()=> $"FirstName LastName");
   
  
  

  
  

Especially the usage of Lazy<> can help in the case of complex creation that is only used in certain places. It will compute the value once on the first call and then return the computed result on all consecutive calls. If the value should be re-evaluated (on the next call to it) you simply instantiate a new version of the Lazy<> instance.

If you would combine the Lazy<> approach with immutability you could also get something like this (which would be my pick, if the constraints allow it):

public class Person

 private Lazy<string> _fullname;

 public Person(string firstName, string lastName)
 
 FirstName = firstName;
 LastName = lastName;
 _fullname = new Lazy<string>($"FirstName LastName");
 

 public string FirstName get; 
 public string LastName get; 
 public string FullName => _fullname.Value;