Wie zwei Klassen Eigenschaften auf den gleichen Wert Referenz machen

Question

Ich versuche, die folgendes zu tun:

Ich möchte zwei Klassen Class01 und Class02 haben. Eine Eigenschaft von Class02Integer wird mit meiner Eigenschaft Integer von Class01 initialisiert. Wenn ich meine Class01 ändere. Integer jetzt möchte ich meine Class02 haben. Integer hat sich ebenfalls geändert. Wie kann ich das machen?

Class01 one = new Class01 { Integer = 16 }; 
Class02 two = new Class02 { Integer = one.Integer }; 

Console.WriteLine("Class one: {0} -- Class two: {1}", one.Integer, two.Integer); 
// Prints: Class one: 16 -- Class two: 16 

one.Integer++; 

Console.WriteLine ("Class one: {0} -- Class two: {1}", one.Integer, two.Integer); 
// Prints:    Class one: 17 -- Class two: 16 
// I want it to print: Class one: 17 -- Class two: 17 

Answer 1

Sie müssen zwischen Referenztypen und Werttypen unterscheiden.

Wenn Sie einen Wert für einen Referenztyp ändern, wird dieser überall dort geändert, wo auf dieses Objekt verwiesen wird.

int ist ein Werttyp. Wenn Sie also die Integer-Eigenschaft in einem Objekt ändern, wird sie nicht automatisch im anderen Objekt aktualisiert.

Class01 ist ein Referenztyp, wenn Sie es in ähnlicher Weise zu Integer Eigenschaft verwendet haben, würde es funktionieren, wie Sie es wollen, dass es funktioniert.

Beispiele für Werttypen: int, double, bool, char, DateTime.

Beispiele für Referenztypen: Form, string, List

die schmutzigste Lösung ist, eine Klasse mit einer variablen static haben, z.B. Class03 mit static int, auf die Class01 und Class02 statt ihrer eigenen Eigenschaften zugreifen und sie aktualisieren könnten, aber ich empfehle das nicht. Abhängig von der Architektur, die Sie möglicherweise entdecken, möchten Sie möglicherweise einen Wrapper für diesen Wert schreiben, indem Sie ihn zu einem Referenztyp machen oder Ereignisse verwenden, um andere Objekte über die Änderung zu benachrichtigen oder eine Art von Vererbung zu verwenden, wenn die Klassen sehr verbunden sind.

Answer 2

Sie können es nicht, weil int Werttyp ist und jede Klasse hat ihre eigene Kopie von int value;

Sie können Klassenwrapper schreiben, die int Wert enthalten und Verweise darauf in Ihren Klassen setzen, oder Sie können versuchen, Box int.

Answer 3

I von 1 Art und Weise kenne, ist es vielleicht nicht die einfachste, aber sein sicheres Arbeiten zu tun:

Sie können einen benutzerdefinierten Ereignishandler machen, diese Klassen in den Event-Handler abonnieren, wenn sie innitialize, sobald sie abonniert hat in der Event-Handler eine öffentliche void für diese Klassen, rufen Sie diese öffentliche void etwas wie öffentliche void UpdateIntegerValue (int), innerhalb dieser Event-Handler auslösen dieses Ereignis mit 1 der Parameter beying den ganzzahligen Wert und ein anderes birgt das Klassenobjekt selbst dann einfach Setzen Sie den Wert für jede Klasseninstanz.

Am Ende wird es so einfach sein, alle zwei Klassen mit 1 Zeile wie UpdateIntegerValueForAllClasses zu aktualisieren (Object ownerclass, int integerToUpdate);

Lassen Sie mich wissen, wenn Sie es nicht vollständig verstanden haben oder weitere Details benötigen.

Answer 4

@JRace

zuordnen Wert von Class01 Objekt wird nur den Wert Kopieren nicht Speicherreferenz. Also, wann immer Sie eine Änderung in one.Integer machen, wird es nie zu two.Integer widerspiegeln. Sie können eine neue Klasse (Referenztyp) mit int-Eigenschaften erstellen, eine Instanz dieser Klasse erstellen und arbeiten. Es wird helfen.

public class Class02 
    { 
     public Data Integer { get; set; } 
    } 
    public class Class01 
    { 
     public Data Integer { get; set; } 
    } 
    public class Data { 

     public int Integer { get; set; } 
    } 
    public class A 
    { 
     private void myFunc() 
     { 
      Data data = new Data(); 
      data.Integer = 16; 
      Class01 one = new Class01 { Integer = data }; 
      Class02 two = new Class02 { Integer = data }; 
      Console.WriteLine("Class one: {0} -- Class two: {1}", one.Integer.Integer, two.Integer.Integer); 
      // Prints: Class one: 16 -- Class two: 16 
      data.Integer++; 
      Console.WriteLine("Class one: {0} -- Class two: {1}", one.Integer.Integer, two.Integer.Integer); 
      // Prints:    Class one: 17 -- Class two: 16 
      // I want it to print: Class one: 17 -- Class two: 17 
     } 
    } 

Answer 5

Wenn Sie eine Variable teilen zwischen alle Instanzen der Klassen, dann können Sie einen übergeordneten Klasse erstellen, von der beide Klassen erben, und definieren eine protected static Variable drin (protected = nur zugänglich zu dieser Klasse und Klassen, die davon erben; static = gemeinsam über den Typ verteilt):

abstract class ClassAbstract{ 
    protected static int _myInteger {get;set;} 
} 

class Class01:ClassAbstract{ 
    public int MyInteger { 
     get{return _myInteger;} 
     set{ _myInteger=value;} 
    } 
} 

class Class02:ClassAbstract{ 
    public int MyInteger { 
     get{return _myInteger;} 
     set{ _myInteger=value;} 
    } 
} 

static class Program { 
    public void Main(){ 
     Class01 one = new Class01(); 
     one.MyInteger = 16; 
     Class02 two = new Class02(); 
     Console.WriteLine("Class two: {0}", two.MyInteger); 
    } 
}