Eu tenho uma classe que, em construção, carrega informações de um banco de dados. As informações são todas modificáveis ​​e, em seguida, o desenvolvedor pode chamar Save () para salvar as informações no banco de dados.

Também estou criando uma classe que será carregada do banco de dados, mas não permitirá atualizações. (uma versão somente para leitura). Minha pergunta é, devo fazer uma classe separada e herdar, ou devo apenas atualizar o objeto existente para obter um parâmetro readonly no construtor, ou devo criar uma classe separada inteiramente?

A classe existente já é usada em muitos lugares no código.

Obrigado.

Atualizar:

Em primeiro lugar, há muitas ótimas respostas aqui. Seria difícil aceitar apenas um. Obrigado a todos.

Os principais problemas que parece são:

Atender às expectativas com base em nomes de classes e estruturas de herança.Evitando código duplicado desnecessário

Parece haver uma grande diferença entre Readable e ReadOnly. Uma classe Readonly provavelmente não deve ser herdada. Mas uma classe Readable sugere que também pode ganhar capacidade de escrita em algum momento.

Então, depois de pensar muito, aqui está o que estou pensando:

<code>public class PersonTestClass
{
    public static void Test()
    {

        ModifiablePerson mp = new ModifiablePerson();
        mp.SetName("value");
        ReadOnlyPerson rop = new ReadOnlyPerson();
        rop.GetName();
        //ReadOnlyPerson ropFmp = (ReadOnlyPerson)mp;  // not allowed.
        ReadOnlyPerson ropFmp = (ReadOnlyPerson)(ReadablePerson)mp; 
          // above is allowed at compile time (bad), not at runtime (good).
        ReadablePerson rp = mp;
    }
}

public class ReadablePerson
{
    protected string name;
    public string GetName()
    {
        return name;
    }        
}
public sealed class ReadOnlyPerson : ReadablePerson
{
}
public class ModifiablePerson : ReadablePerson
{
    public void SetName(string value)
    {
        name = value;
    }
}
</code>

Infelizmente, eu ainda não sei como fazer isso com propriedades (veja a resposta da StriplingWarrior para isso feito com propriedades), mas eu tenho a sensação de que isso envolverá a palavra-chave protegida emodificadores de acesso a propriedades assimétricas.

Além disso, felizmente para mim, os dados que são carregados do banco de dados não precisam ser transformados em objetos de referência, ao contrário, eles são tipos simples. Isso significa que eu realmente não tenho que me preocupar com pessoas modificando os membros doReadOnlyPerson objeto.

Atualização 2:

Note, como StriplingWarrior sugeriu, downcasting pode levar a problemas, mas isso geralmente é verdade, já que mandar um Monkey para um Animal de volta para um Dog pode ser ruim. No entanto, parece que, embora a conversão seja permitida em tempo de compilação, ela não é realmente permitida em tempo de execução.

Uma classe wrapper também pode fazer o truque, mas eu gosto disso melhor porque evita o problema de ter que copiar profundamente o objeto passado / permitir que o objeto passado seja modificado, modificando assim a classe wrapper.