Réinitialiser avec un nouvel objet

Question

Dans le code ci-dessous, je voudrais utiliser le code dans la méthode de chargement statique pour actualiser l'objet ... mais comment réinitialiser l'objet actuel avec un nouvel objet? Copier le champ par champ est le seul moyen?

class WIP 
{ 
    // <Snipped> Various other properties... 
    public Boolean Refresh() 
    { 
     // Need to change the current object with the updated object 
     this = WIP.Load(this.ObjectID); // Says this is readonly... 
     return true; 
    } 

    public static WIP Load(long ObjectID) 
    { 
     // This static method fetches the data from DB and returns the object. 
    } 
} 

Edit: Je viens d'avoir cette idée après avoir affiché la question ... Y a-t-il des pièges dans ce domaine?

class WIP 
{ 
    // <Snipped> Various other properties... 
    public Boolean Refresh() 
    { 
     // This method fetches the data from DB and updates the object. 
    } 

    public static WIP Load(long ObjectID) 
    { 
     WIP newObject = new WIP(); 
     newObject.ObjectID = ObjectID; 
     newObject.Refresh(); 
     return newObject; 
    } 
} 

Answer 1

Non, vous ne pouvez pas. Le plus proche, vous pouvez venir est essentiellement de copier chaque membre - ce qui ne va pas fonctionner si certains sont en lecture seule, bien sûr. Soit vous essayez de rendre votre objet immuable - dans ce cas ne devrait pas changer sous les pieds de code qui a déjà une référence à votre objet - ou vous ne l'êtes pas, auquel cas vous juste besoin de faire entièrement mutable (idéalement de façon atomique s'il y a plusieurs threads impliqués).

Answer 2

Vous ne pouvez pas utiliser this mot-clé dans une méthode statique. Par conséquent, vous ne pouvez pas non plus utiliser les variables d'instance.

Answer 3

Vous ne pouvez pas. Pensez simplement que tous les autres objets contenant une référence à l'objet que vous essayez de "rafraîchir" devraient être mis à jour. Vous n'avez que la chance d'ajouter un niveau d'indirection ou de modifier la conception de votre logiciel.

Answer 4

La méthode Static indique qu'il s'agit d'une implémentation de type "Factory-Style". Par conséquent devrait être utilisé pour créer ou obtenir de nouvelles instances d'objets.

La méthode Refresh de l'autre côté serait naturellement utilisée pour rafraîchir les propriétés de l'objet actuel et laisser la référence des objets intacte.

Utilisation:

// Initialize the object 
WIP myWip = WIP.Load(1); 
Console.WriteLine(myWip.ObjectId); 
// Refresh the object from underlying data store 
myWip.Refresh(); 


// <Snipped> Various other properties... 
public Boolean Refresh() 
{ 
    //Read the values from data store and refresh the properties...   
    return true; 
} 

public static WIP Load(long ObjectID) 
{ 
    // This static method fetches the data from DB and returns the object. 
} 

Pour le cycle de vie de gestion des objets j'utiliser certaines usines. Vous pourriez jeter un coup d'oeil au modèle d'usine ->http://en.wikipedia.org/wiki/Factory_method_pattern.

Answer 5

On dirait que vous avez besoin « usine de travaux en cours »:

class WIP 
{ 
    private static Dictionary<long, WIP> instances = new Dictionary<long, WIP>(); 
    private WIP() 
    { 
     ... 
    } 


    // <Snipped> Various other properties... 
    public Boolean Refresh() 
    { 
     // This method fetches the data from DB and updates the object. 
    } 

    public static WIP Load(long ObjectID) 
    { 
     WIP wip = null; 
     if (instances.ContainsKey(ObjectID)) 
     { 
      wip = instances[ObjectID]; 
     } 
     else 
     { 
      wip = new WIP(); 
      wip.ObjectID = ObjectID; 
      instances.Add(ObjectID, wip); 
     } 
     wip.Refresh(); 

     return wip; 
    } 
} 

Cela entraînera que la seule façon d'obtenir instance de WIP est par la méthode « Load » statique, et vous utiliserez la même instance pour chaque ObjectID contrairement à votre code actuel qui permet à quiconque de créer une nouvelle instance pour le même ID. De cette façon, appeler l'actualisation mettra à jour toutes les instances, peu importe où elles se trouvent.