sobrecarga - operadores logicos c# ejemplos

¿Hay alguna solución para sobrecargar el operador de asignación en C#?

Question

A diferencia de C ++, en C # no puede sobrecargar el operador de asignación.

Estoy haciendo una clase numérica personalizada para operaciones aritméticas con números muy grandes y quiero que tenga la apariencia de los tipos numéricos incorporados, como int, decimal, etc. He sobrecargado los operadores aritméticos, pero la tarea permanece ...

Aquí hay un ejemplo:

Number a = new Number(55); 
Number b = a; //I want to copy the value, not the reference

¿Hay alguna solución para ese problema?

Answer 1

En lugar de hacer una copia de los datos al pasar la referencia, puede hacer que la clase sea inmutable. Cuando la clase es inmutable, tener múltiples referencias a ella no es un problema ya que no se puede cambiar.

Las operaciones que cambian los datos, por supuesto, devolverán nuevas instancias.

Answer 2

No podrá trabajar con el aspecto de C ++, ya que a = b; tiene otra semántica en C ++ que en C #. En C #, a = b; hace un punto al mismo objeto como b. En C ++, a = b cambia el contenido de a. Ambos tienen sus altibajos. Es como tu lo haces

MyType * a = new MyType();
MyType * b = new MyType(); 
a = b; /* only exchange pointers. will not change any content */

En C ++ (perderá la referencia al primer objeto y creará una pérdida de memoria. Pero ignorémoslo aquí). No puede sobrecargar el operador de asignación en C ++ para eso tampoco.

La solución es fácil:

MyType a = new MyType();
MyType b = new MyType();

// instead of a = b
a.Assign(b);

Descargo de responsabilidad : no soy un desarrollador de C #

Puede crear una propiedad de solo escritura como esta. luego haz a.Self = b; encima.

public MyType Self {
    set {
        /* copy content of value to this */
        this.Assign(value);
    }
}

Ahora, esto no es bueno. Ya que viola el principio de la menor sorpresa (POLS). Uno no esperaría que cambiara si uno hace a.Self = b;

Answer 3

Todavía no tengo claro para nada que realmente lo necesites. Ya sea:

• Su tipo de número debe ser una estructura (lo que es probable, los números son el ejemplo más común de estructuras). Tenga en cuenta que todos los tipos que desea que su tipo actúe (int, decimal, etc.) son estructuras.

o:

• Su tipo de Número debe ser inmutable, haciendo que cada operación de mutación devuelva una nueva instancia, en cuyo caso no necesita copiar los datos en la asignación de todos modos. (De hecho, su tipo debe ser inmutable sea o no una estructura. Las estructuras mutables son malas, y un número ciertamente no debe ser un tipo de referencia mutable).

Answer 4

Una publicación anterior sugirió esto:

operador implícito estático público Foo (string normalString) {}

Intenté este enfoque ... pero para que funcione, necesitas esto:

operador implícito estático público Foo (Foo original) {}

y el compilador no le permitirá tener una función de conversión implícita de su tipo exacto, ni de ningún tipo base de usted mismo. Eso tiene sentido ya que sería una forma de puerta trasera de anular el operador de asignación, que C # no quiere permitir.

Answer 5

puede usar la palabra clave ''implícita'' para crear una sobrecarga para la asignación:

Supongamos que tiene un tipo como Foo, que cree que se puede convertir implícitamente de una cadena. Escribirías el siguiente método estático en tu clase Foo:

public static implicit operator Foo(string normalString)
{
    //write your code here to go from string to Foo and return the new Foo.
}

Una vez hecho esto, puede usar lo siguiente en su código:

Foo x = "whatever";

Answer 6

Tal vez lo que estás buscando se puede resolver usando accesos C #.

http://msdn.microsoft.com/en-us/library/aa287786(v=vs.71).aspx

Answer 7

Aquí hay una solución que funcionó para mí:

public class MyTestClass
{
   private int a;
   private string str;

   public MyTestClass()
   {
      a = 0;
      str = null;
   }

   public MyTestClass(int a, string str)
   {
      this.a = a;
      this.str = str;
   }

   public MyTestClass Clone
   {
      get
      {
         return new MyTestClass(this.a, this.str);
      }
   }
}

En algún otro lado en el código:

MyTestClass test1 = new MyTestClass(5, "Cat");
MyTestClass test2 = test1.Clone;