Eu precisava mostrar uma copia de um certo objeto em C#, e a duras penas, descobri que se simplesmente usarmos o operador =, ele só fará uma copia com a referencia de memoria do objeto base [shallow copy], portanto a cada mudança em qualquer um dos objetos, essa será replicada nos dois, pois são a mesma posição na memoria .

Mas eu necessitava que fosse copias independentes [deep copy], para que eu alterasse propriedades de um sem afetar o outro, nessas pesquisas encontrei a classe a seguir que faz a extensão de métodos(disponível a partir do C# 3), ao inserir essa classe no seu projeto, será incorporado automaticamente aos objetos do seu projeto os métodos inclusos na classe a seguir.

Segue o código:

[sections] [section title=”Código Fonte C#”]

public static class ObjectExtensions
{
private static readonly MethodInfo CloneMethod = typeof (Object).GetMethod("MemberwiseClone",
BindingFlags.NonPublic | BindingFlags.Instance);

public static bool IsPrimitive(this Type type)
{
if (type == typeof (String)) return true;
return (type.IsValueType & type.IsPrimitive);
}

public static Object Copy(this Object originalObject)
{
return InternalCopy(originalObject, new Dictionary<Object, Object>(new ReferenceEqualityComparer()));
}

private static Object InternalCopy(Object originalObject, IDictionary<Object, Object> visited)
{
if (originalObject == null) return null;
Type typeToReflect = originalObject.GetType();
if (IsPrimitive(typeToReflect)) return originalObject;
if (visited.ContainsKey(originalObject)) return visited[originalObject];
if (typeof (Delegate).IsAssignableFrom(typeToReflect)) return null;
object cloneObject = CloneMethod.Invoke(originalObject, null);
if (typeToReflect.IsArray)
{
Type arrayType = typeToReflect.GetElementType();
if (IsPrimitive(arrayType) == false)
{
var clonedArray = (Array) cloneObject;
clonedArray.ForEach(
(array, indices) => array.SetValue(InternalCopy(clonedArray.GetValue(indices), visited), indices));
}
}
visited.Add(originalObject, cloneObject);
CopyFields(originalObject, visited, cloneObject, typeToReflect);
RecursiveCopyBaseTypePrivateFields(originalObject, visited, cloneObject, typeToReflect);
return cloneObject;
}

private static void RecursiveCopyBaseTypePrivateFields(object originalObject, IDictionary<object, object> visited,
object cloneObject, Type typeToReflect)
{
if (typeToReflect.BaseType != null)
{
RecursiveCopyBaseTypePrivateFields(originalObject, visited, cloneObject, typeToReflect.BaseType);
CopyFields(originalObject, visited, cloneObject, typeToReflect.BaseType,
BindingFlags.Instance | BindingFlags.NonPublic, info => info.IsPrivate);
}
}

private static void CopyFields(object originalObject, IDictionary<object, object> visited, object cloneObject,
Type typeToReflect,
BindingFlags bindingFlags =
BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.FlattenHierarchy,
Func<FieldInfo, bool> filter = null)
{
foreach (FieldInfo fieldInfo in typeToReflect.GetFields(bindingFlags))
{
if (filter != null && filter(fieldInfo) == false) continue;
if (IsPrimitive(fieldInfo.FieldType)) continue;
object originalFieldValue = fieldInfo.GetValue(originalObject);
object clonedFieldValue = InternalCopy(originalFieldValue, visited);
fieldInfo.SetValue(cloneObject, clonedFieldValue);
Application.DoEvents();
}
}

public static T Copy<T>(this T original)
{
return (T) Copy((Object) original);
}
}

public class ReferenceEqualityComparer : EqualityComparer<Object>
{
public override bool Equals(object x, object y)
{
return ReferenceEquals(x, y);
}

public override int GetHashCode(object obj)
{
if (obj == null) return 0;
return obj.GetHashCode();
}
}

namespace ArrayExtensions
{
public static class ArrayExtensions
{
public static void ForEach(this Array array, Action<Array, int[]> action)
{
if (array.LongLength == 0) return;
var walker = new ArrayTraverse(array);
do action(array, walker.Position); while (walker.Step());
}
}

internal class ArrayTraverse
{
private readonly int[] _maxLengths;
public int[] Position;

public ArrayTraverse(Array array)
{
_maxLengths = new int[array.Rank];
for (int i = 0; i < array.Rank; ++i)
{
_maxLengths[i] = array.GetLength(i) – 1;
}
Position = new int[array.Rank];
}

public bool Step()
{
for (int i = 0; i< Position.Length; ++i)
{
if (Position[i] < _maxLengths[i])
{
Position[i]++;
for (int j = 0; j < i; j++)
{
Position[j] = 0;
}
return true;
}
}
return false;
}
}
}

Para fazer a cópia use assim:

ObjetoCopiado = ObjetoOriginal.Copy();

Sendo esses dois objetos do mesmo tipo.

[/section] [/sections]
Obrigado e até o próximo post.

DATEK Tecnologia Eletrônica
[C#] Classes para cópia de objetos integralmente [deep copy]
Tags:                     

Deixe uma resposta

%d blogueiros gostam disto: