Mit Hilfe einer Schnittstelle ein Objekt von einem Typ in einen anderen zu konvertieren?

Question

Angenommen, ich habe zwei Klassen mit der gleichen Schnittstelle:

interface ISomeInterface 
{
    int foo{get; set;}
    int bar{get; set;}
}

class SomeClass : ISomeInterface {}

class SomeOtherClass : ISomeInterface {}

Angenommen, ich eine Instanz von ISomeInterface haben, die eine Someclass darstellt. Gibt es eine einfache Möglichkeit, dass in eine neue Instanz von SomeOtherClass zu kopieren, ohne jedes Mitglied Kopieren von Hand?

UPDATE: Für das Protokoll, ich bin nicht versuchen, die Instanz von Someclass in die Instanz von SomeOtherClass zu werfen. Was ich möchte, ist, etwas zu tun wie folgt aus:

ISomeInterface sc = new SomeClass() as ISomeInterface;
SomeOtherClass soc = new SomeOtherClass();

soc.foo = sc.foo;
soc.bar = soc.bar;

Ich will nur nicht, dass von Hand für jeden zu tun haben, wie diese Objekte viele Eigenschaften haben.

Answer 1

„? Würden Sie in der Lage, mir ein Beispiel dafür, wie ich das tun kann (oder zumindest zeigen Sie mich auf den richtigen Methoden zu verwenden) Ich scheine nicht in der Lage sein, sie auf MSDN zu finden“ - Jason Baker

Jason, etwa wie folgt:

var props = typeof(Foo)
            .GetProperties(BindingFlags.Public | BindingFlags.Instance);

foreach (PropertyInfo p in props)
{
     // p.Name gives name of property
}

Ich würde vorschlagen, ein Tool zu schreiben den Code für einen Copykonstruktor musst auszuspucken, im Gegensatz zu ihm reflexiv zur Laufzeit zu tun -. Was wäre weniger performant

Answer 2

Sie können die implizite Operatoren erstellen in jeder Klasse die Konvertierung für Sie zu tun:

public class SomeClass
{
    public static implicit operator SomeOtherClass(SomeClass sc)
    {
        //replace with whatever conversion logic is necessary
        return new SomeOtherClass()
        {
            foo = sc.foo,
            bar = sc.bar
        }
    }

    public static implicit operator SomeClass(SomeOtherClass soc)
    {
        return new SomeClass()
        {
            foo = soc.foo,
            bar = soc.bar
        }
    }
    //rest of class here
}

und dann SomeOtherClass soc = sc; und umgekehrt funktionieren würden.

Answer 3

Ist das nicht der Punkt einer Schnittstelle zu haben, um nicht das zu tun? Tun Sie etwas mit der konkreten Umsetzung von SomeOtherClass? Statt die konkrete Umsetzung, die Schnittstelle verwenden und es sollte keine Rolle, ob Sie oder Someclass someother-Klasse verwenden.

Other than that, das Beste, was Sie tun können, ist eine Art von einer Hilfsfunktion zu schreiben (Sie würden immer noch manuell zu tun haben, oder schauen Sie in Reflexion), dass Kopien jede Eigenschaft in der Schnittstelle, die wie folgt aussehen:

   public ISomeInterface CopyValues(ISomeInterface fromSomeClass, ISomeInterface toSomeOtherClass)
   {
    //copy properties here
    return toSomeOtherClass;
    }

Allerdings ist mein erster Instinkt wäre aus der Umsetzung zu sagen bleiben weg und konzentrieren sich stattdessen mit Ihrer Schnittstelle, dann wird es keine Rolle, was sich darunter lügt.

Answer 4

Reflection ... Schleife durch jede Eigenschaft, und es auf der entsprechende Eigenschaft auf dem anderen Objekt festgelegt.

Answer 5

Schauen Sie sich Joes Antwort für die Reflexion Lösung.

Ich nehme an, Sie Visual Studio verwenden.

Sind Sie mit der Strg + Shift + r und Strg + Shift + p Verknüpfungen? Wenn nicht, Strg + Shift + r beginnt / endet einen Tastendruck Makroaufnahme. Strg + Shift + p spielt den aufgezeichneten Makro.

Was ich getan habe, als ich viele Eigenschaften festgelegt haben, ist die Eigenschaft Erklärungen kopieren, wo ich will, dass sie eingestellt werden und ein Makro für Mutieren der Erklärung auf eine Reihe Aussage und bewegt den Cursor in die nächste Zeile aufzuzeichnen ich spiele es, dann nur, bis ich alle eingestellten Aussagen gemacht.

Answer 6

Nein, um transparent zu konvertieren (cast) ein Objekt von einem Typ zum anderen, die zugrundeliegende konkrete Klasse des Objekts, das Sie haben, müssen von der Klasse erben die Sie versuchen, es zu werfen, auch wenn sie beide die gleiche inplement Schnittstelle.

Denken Sie darüber nach, alle zwei Objekte gemeinsam haben die gleiche Schnittstelle zu implementieren, ist die gleiche Teilmenge von Methodensignaturen. Sie könnten nicht (wahrscheinlich nicht) haben sogar die gleichen Eigenschaften oder Datenfelder.

Answer 7

würde das nicht?

class MyClass : ICloneable
{
public MyClass()
{

}
public object Clone() // ICloneable implementation
{
MyClass mc = this.MemberwiseClone() as MyClass;

return mc;
}

Sie nur anrufen müssen: MyClass.Clone ().

Answer 8

   ISomeInterface sc = new SomeClass() as ISomeInterface;
   SomeOtherClass soc = new SomeOtherClass();
   foreach (PropertyInfo info in typeof(ISomeInterface)
                                     .GetProperties(BindingFlags.Instance
                                                     |BindingFlags.Public))
   {
       info.SetValue(soc,info.GetValue(sc,null),null);
   }

Answer 9

Ich habe wie folgt und es funktioniert sehr gut von einem Objekt in ein anderes mit impliziten Operator zu konvertieren:

class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("hello");
            ExecutionReport er = new ExecutionReport("ORDID1234",3000.43,DateTime.UtcNow);
            Order ord = new Order();
            ord = er;
            Console.WriteLine("Transferred values are : " + er.OrderId + "\t" + ord.Amount.ToString() + "\t" + ord.TimeStamp.ToString() + "\t");
            Console.ReadLine();
        }
    }


    public  class Order
    {
        public string OrderId { get; set; }
        public double Amount { get; set; }
        public DateTime TimeStamp { get; set; }
        public static implicit operator ExecutionReport(Order ord)
        {
            return new ExecutionReport()
            {
                OrderId = ord.OrderId,
                Amount = ord.Amount,
                TimeStamp = ord.TimeStamp
            };
        }
        public static implicit operator Order(ExecutionReport er)
        {
            return new Order()
            {
                OrderId = er.OrderId,
                Amount = er.Amount,
                TimeStamp = er.TimeStamp
            };
        }

        public Order()
        { }
    }

    public  class ExecutionReport
    {
        public string OrderId { get; set; }
        public double Amount { get; set; }
        public DateTime TimeStamp { get; set; }
        public ExecutionReport() { }
        public ExecutionReport(string orderId,double amount, DateTime ts)
        {
            OrderId = orderId; Amount = amount; TimeStamp = ts;
        }
    }