Automatycznie stosować wartości właściwości z jednego obiektu do drugiego tego samego typu?

Ponieważ wierzę, że wersja Jona jest zbyt skomplikowana, a wersja Steve ' a zbyt prosta, i podoba mi się pomysł Daniela o klasie rozszerzonej.

Plus Wersja generyczna jest ładna, ale niepotrzebna, ponieważ wszystkie elementy są obiektami.

Kod:

using System;
using System.Reflection;
/// <summary>
/// A static class for reflection type functions
/// </summary>
public static class Reflection
{
    /// <summary>
    /// Extension for 'Object' that copies the properties to a destination object.
    /// </summary>
    /// <param name="source">The source.</param>
    /// <param name="destination">The destination.</param>
    public static void CopyProperties(this object source, object destination)
    {
        // If any this null throw an exception
        if (source == null || destination == null)
            throw new Exception("Source or/and Destination Objects are null");
            // Getting the Types of the objects
        Type typeDest = destination.GetType();
        Type typeSrc = source.GetType();

        // Iterate the Properties of the source instance and  
        // populate them from their desination counterparts  
        PropertyInfo[] srcProps = typeSrc.GetProperties();
        foreach (PropertyInfo srcProp in srcProps)
        {
            if (!srcProp.CanRead)
            {
                continue;
            }
            PropertyInfo targetProperty = typeDest.GetProperty(srcProp.Name);
            if (targetProperty == null)
            {
                continue;
            }
            if (!targetProperty.CanWrite)
            {
                continue;
            }
            if (targetProperty.GetSetMethod(true) != null && targetProperty.GetSetMethod(true).IsPrivate)
            {
                continue;
            }
            if ((targetProperty.GetSetMethod().Attributes & MethodAttributes.Static) != 0)
            {
                continue;
            }
            if (!targetProperty.PropertyType.IsAssignableFrom(srcProp.PropertyType))
            {
                continue;
            }
            // Passed all tests, lets set the value
            targetProperty.SetValue(destination, srcProp.GetValue(source, null), null);
        }
    }
}

Użycie:

/// <summary>
/// ExampleCopyObject
/// </summary>
/// <returns></returns>
public object ExampleCopyObject()
{
    object destObject = new object();
    this.CopyProperties(destObject); // inside a class you want to copy from

    Reflection.CopyProperties(this, destObject); // Same as above but directly calling the function

    TestClass srcClass = new TestClass();
    TestStruct destStruct = new TestStruct();
    srcClass.CopyProperties(destStruct); // using the extension directly on a object

    Reflection.CopyProperties(srcClass, destObject); // Same as above but directly calling the function

    //so on and so forth.... your imagination is the limits :D
    return srcClass;
}

public class TestClass
{
    public string Blah { get; set; }
}
public struct TestStruct
{
    public string Blah { get; set; }
}

Jak się nudziłem i wersja linq została zasugerowana przez komentarz

using System;
using System.Linq;
using System.Reflection;
/// <summary>
/// A static class for reflection type functions
/// </summary>
public static class Reflection
{
    /// <summary>
    /// Extension for 'Object' that copies the properties to a destination object.
    /// </summary>
    /// <param name="source">The source.</param>
    /// <param name="destination">The destination.</param>
    public static void CopyProperties(this object source, object destination)
    {
        // If any this null throw an exception
        if (source == null || destination == null)
            throw new Exception("Source or/and Destination Objects are null");
        // Getting the Types of the objects
        Type typeDest = destination.GetType();
        Type typeSrc = source.GetType();
        // Collect all the valid properties to map
        var results = from srcProp in typeSrc.GetProperties()
                                    let targetProperty = typeDest.GetProperty(srcProp.Name)
                                    where srcProp.CanRead
                                    && targetProperty != null
                                    && (targetProperty.GetSetMethod(true) != null && !targetProperty.GetSetMethod(true).IsPrivate)
                                    && (targetProperty.GetSetMethod().Attributes & MethodAttributes.Static) == 0
                                    && targetProperty.PropertyType.IsAssignableFrom(srcProp.PropertyType)
                                    select new { sourceProperty = srcProp, targetProperty = targetProperty };
        //map the properties
        foreach (var props in results)
        {
            props.targetProperty.SetValue(destination, props.sourceProperty.GetValue(source, null), null);
        }
    }
}

Bazując na metodzie Steve ' a, wybrałem metodę rozszerzania. To używa mojej klasy bazowej jako typu, ale powinno być użyteczne nawet przy użyciu obiektu jako typów param. Działa świetnie do moich zastosowań.

using System.Reflection;
//*Namespace Here*
public static class Ext
{
    public static void CopyProperties(this EntityBase source, EntityBase destination)
    {
        // Iterate the Properties of the destination instance and  
        // populate them from their source counterparts  
        PropertyInfo[] destinationProperties = destination.GetType().GetProperties(); 
        foreach (PropertyInfo destinationPi in destinationProperties)
        {
            PropertyInfo sourcePi = source.GetType().GetProperty(destinationPi.Name);     
            destinationPi.SetValue(destination, sourcePi.GetValue(source, null), null);
        } 
    }
}

Użycie wygląda tak:

item1.CopyProperties(item2);

Teraz Item2 ma te same dane właściwości jak item1.

Oto krótka i słodka Wersja, ponieważ powiedziałeś, że oba Twoje obiekty są tego samego typu:

foreach (PropertyInfo property in typeof(YourType).GetProperties())
{
    property.SetValue(targetObject, property.GetValue(sourceObject, null), null);
}

Modyfikacja wersji Daniela w celu uniknięcia WYJĄTKÓW.

foreach (PropertyInfo property in typeof(YourType).GetProperties())
{
  if (property.CanWrite)
  {
    property.SetValue(marketData, property.GetValue(market, null), null);
  }
}

Istnieje Iclonable i obiekt.MemberwiseClone (shallow copy) (tworzą one zupełnie nowy obiekt, więc mogą nie spełniać Twoich wymagań).

Możesz użyć reflection, aby zrobić to samodzielnie(dziedziczyć z klasy bazowej, więc nie musisz ponownie implementować).

Albo możesz wygenerować kod.

Możesz spróbować czegoś takiego....

MyType destination = new MyType();
MyType source = new MyType();

// Iterate the Properties of the destination instance and 
// populate them from their source counterparts

PropertyInfo[] destinationProperties = destination.GetType().GetProperties();
foreach (PropertyInfo destinationPI in destinationProperties)
{
    PropertyInfo sourcePI = source.GetType().GetProperty(destinationPI.Name);

    destinationPI.SetValue(destination,
                           sourcePI.GetValue(source, null), 
                           null);
}

Możesz użyć serializacji do głębokiego klonowania obiektu:

public static T DeepClone<T>(this T objectToClone) where T: BaseClass
{
    BinaryFormatter bFormatter = new BinaryFormatter();
    MemoryStream stream = new MemoryStream();
    bFormatter.Serialize(stream, objectToClone);
    stream.Seek(0, SeekOrigin.Begin);
    T clonedObject = (T)bFormatter.Deserialize(stream);
    return clonedObject;
}

Klasy musiałyby być oczywiście oznaczone Serializowalne.

Jeśli chcesz coś takiego jak ApplyProperties, możesz napisać metodę rozszerzenia na obiekcie, która zrobi to, czego potrzebujesz. Po prostu zdaj sobie sprawę, że taka metoda rozszerzenia nie byłaby "czysta", ani wolna od skutków ubocznych. Ale jeśli potrzebujesz zdolności, to sposób, aby to osiągnąć.

Ta krótka i prosta metoda rozszerzenia pozwoli na kopiowanie pasujących właściwości z jednego obiektu do drugiego z sprawdzeniem wartości Null i jest zapisywalna.

public static void CopyPropertiesTo(this object fromObject, object toObject)
    {
        PropertyInfo[] toObjectProperties = toObject.GetType().GetProperties();
        foreach (PropertyInfo propTo in toObjectProperties)
        {
            PropertyInfo propFrom = fromObject.GetType().GetProperty(propTo.Name);
            if (propFrom!=null && propFrom.CanWrite)
                propTo.SetValue(toObject, propFrom.GetValue(fromObject, null), null);
        }
    }

Od kilku lat korzystam z popularnej biblioteki o nazwie ValueInjecter

Nuget: https://www.nuget.org/packages/ValueInjecter/

Github: https://github.com/omuleanu/ValueInjecter

target.InjectFrom(source);
target.InjectFrom<Injection>(source);
target.InjectFrom(new Injection(parameters), source);
target.InjectFrom<Injection>(); // without source

Zauważ, że nawet jeśli podstawowe rozwiązania są dość proste( zobacz inne odpowiedzi), istnieje wiele przypadków brzegowych (np. deep copy, generics, null values) i optymalizacji (np. cache the reflected properties), więc lepiej używać utrzymywanej biblioteki za to.