Class Initializers C#

Question

I have a class used in several places in my code (Credentials) there is a method that will require much more data I want all of it in one class (ArchiveData) including the original (Credentials) class

So when I create the class I simply want to assign all the data from the smaller class into the larger class. What is the best practices method of doing this?

There was a similar question here Are class initializers possible in C#? and it was recommended not to overwrite the initialize propery. I don't necessarily want to I just want an overload method which adds known values for me so I can have cleaner code, but giving it an overload will override the default initializer.

Although in this case I will always have the subclass so removing the original initializer is fine in this example. I can see scenarios where I would not want this.

Edit: Removed Stack Overflow Error The main question is about best pactices and pros/cons from various ways of "eating a subclass."

Code below:

Desired end result is a clean way of making a larger class have all data of a smaller class:

Credentials credentials = new Credentials("My User Name", "some password");
ArchiveData AD = new ArchiveData(credentials); 
Console.Write(AD.credentials.UserID); 
Console.Write(AD.credentials.password);

Setup of Classes:

public partial class ArchiveData 
{
    public string DocumentType { get; set; }
    public int RTKD { get; set; }
    public string RTMSG { get; set; }

    public Credentials credentials;

    public ArchiveData(Credentials credentials)        
    {
        this.credentials = credentials;
    }
}


public class Credentials
{
    public string userId { get; set; }
    public string password { get; set; }

    public Credentials(string userId, string password)
    {
        this.userId = userId;
        this.password = password;
    }
}

Answer 1

Inheritance should form an "is-a" relationship. So you could have Dog : Animal because a dog is an animal. That's not the only factor that matters when deciding whether a class should inherit from another, but it's a good starting point.

In this case it's hard to tell whether this is true. Can you say "Archive data is a set of credentials?" If so, iamruss's answer above is probably the way to go. But maybe you want to say "Archive data has a set of credentials." (Or, equivalently "contains a"). In that case, you can do something like this:

public class ArchiveData
{
    public Credentials credentials {get; private set;}

    public string userData
    {
        get
        {
            return this.userData;
        }
        set
        {
            this.userData = value;
        }
    }        

    //other properties here

    public ArchiveData(Credentials credentials)        
    {            
        this.credentials = credentials;
    }
}


public class Credentials
{
    public string userId { get; set; }
    public string password { get; set; }

    public Credentials(string userId, string password)
    {
        this.userId = userId;
        this.password = password;
    }
}

Now if you want to get the user id and password, your code snippet would look like:

Credentials credentials = new Credentials("My User Name", "some password");
ArchiveData AD = new ArchiveData(credentials); 
Console.Write(AD.credentials.UserID); 
Console.Write(AD.credentials.password);

This is a much more flexible and lightweight approach than inheritance, so it's good to understand when you should choose inheritance and when you should choose containment, and go with the best one.

Answer 2

Welcome to the world of OOP!

public class ArchiveData : Credentials
{
    public string userData
    {
        get
        {
            return this.userData;
        }
        set
        {
            this.userData = value;
        }
    }        

    //other properties here

    public ArchiveData(string userId, string password) : base(userId, password) {}
}


public class Credentials
{
    public string userId { get; set; }
    public string password { get; set; }

    public Credentials(string userId, string password)
    {
        this.userId = userId;
        this.password = password;
    }
}

Answer 3

First, you should not extend from Credentials unless that is what you really want (according to the Liskov Substitution Principle). What you seem to want to do is something like this Composite Object example demonstrates:

class Program
{
    static void Main(string[] args)
    {
        var credentials = new Credentials("My User Name", "some password");
        var AD = new ArchiveData(credentials);
        Console.Write(AD.UserId);
        Console.Write(AD.Password);
    }
}

public class ArchiveData
{
    private readonly Credentials myCredentials;

    public string UserData { get; set; }
    public string UserId
    {
        get
        {
            return this.myCredentials.UserId;
        }
    }

    public string Password
    {
        get
        {
            return this.myCredentials.Password;
        }
    }

    public ArchiveData(Credentials credentials)
    {
        if (credentials == null)
        throw new ArgumentNullException();
        this.myCredentials = credentials;
    }
}

public class Credentials
{
    public string UserId { get; set; }
    public string Password { get; set; }

    public Credentials(string userId, string password)
    {
        this.UserId = userId;
        this.Password = password;
    }
}

One of the benefits of doing it this way (as opposed to breaking the LSP) is that you can't feed new instances of ArchiveData, with old instances of ArchiveData, because ArchiveData is not also a Credentials, and thus, not a valid parameter for the constructor.