25

I was wondering, why can't I overload '=' in C#? Can I get a better explanation?

Improve this question
3
  • Do you have a specific case in mind you could share with us in which you want to overload the = ? Commented Mar 1, 2009 at 6:40
  • @Neil N I for instance need to overload operator = for different type of points on left and right side. I have defined my own class MyPoint {double X, double Y} and I want overloaded operator = to be able to copy X and Y from System.Windows.Point on right side. static public MyPoint operator = (System.Windows.Point winPt) {...} Seems to me like a good idea. Commented May 25, 2017 at 8:51
  • @Peter, it sounds like you want to CLONE an object, and not do a reference copy, like the = operator does. Commented May 25, 2017 at 21:23

12 Answers 12

Reset to default
37

Memory managed languages usually work with references rather than objects. When you define a class and its members you are defining the object behavior, but when you create a variable you are working with references to those objects.

Now, the operator = is applied to references, not objects. When you assign a reference to another you are actually making the receiving reference point to the same object that the other reference is.

Type var1 = new Type(); Type var2 = new Type(); var2 = var1;

In the code above, two objects are created on the heap, one referred by var1 and the other by var2. Now the last statement makes the var2 reference point to the same object that var1 is referring. After that line, the garbage collector can free the second object and there is only one object in memory. In the whole process, no operation is applied to the objects themselves.

Going back to why = cannot be overloaded, the system implementation is the only sensible thing you can do with references. You can overload operations that are applied to the objects, but not to references.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

Thanks, but I cannot see, how this answers the question ?
@user492238: operator= is not an operation on the object, but on the reference. You can overload operators that are applied to objects, but you cannot redefine operators applied to references, and in this particular case, doing so would change the semantics of the language: a reference type would behave as a value type.
@DavidRodríguez-dribeas This is an oft-repeated statement, but it's a tautology - it restates the fact, but doesn't provied any reasoning. In C#, operator= acts exactly as if it was static void assign(ref Type dst, in Type src) { dst = src; }. How do we know that? You can do a machine translation of a C# source and replace all assignments (except the one in assign itself :) with invocations of assign and the program will act the same. Heck, it'll all get inlined and there's no overhead (I've tried it). It's a pity that the language doesn't expose this.
15

If you overloaded '=' you would never be able to change an object reference after it's been created. ... think about it - any call to theObjectWithOverloadedOperator=something inside the overloaded operator would result in another call to the overloaded operator... so what would the overloaded operator really be doing ? Maybe setting some other properties - or setting the value to a new object (immutability) ? Generally not what '=' implies..

You can, however, override the implicit & explicit cast operators: http://www.blackwasp.co.uk/CSharpConversionOverload.aspx

Improve this answer

1 Comment

The use of such an overloadable = operator would not be to make something with the object pointed to by the reference, but to 'know' that something was assigned to the variable. This is important in scenarios, where value type semantic is needed and/or for immediate disposal (at least).
9

Because it doesn't really make sense to do so.

In C# = assigns an object reference to a variable. So it operates on variables and object references, not objects themselves. There is no point in overloading it depending on object type.

In C++ defining operator= makes sense for classes whose instances can be created e.g. on stack because the objects themselves are stored in variables, not references to them. So it makes sense to define how to perform such assignment. But even in C++, if you have set of polymorphic classes which are typically used via pointers or references, you usually explicitly forbid copying them like this by declaring operator= and copy constructor as private (or inheriting from boost::noncopyable), because of exactly the same reasons as why you don't redefine = in C#. Simply, if you have reference or pointer of class A, you don't really know whether it points to an instance of class A or class B which is a subclass of A. So do you really know how to perform = in this situation?

Improve this answer

6 Comments

Ok using your terms, it would then make sense to overload the "reference assignment operator". Following Scenario: You want to get a notification for a reference in a collection being updated/changed. so collection[0] = new Value()... So some framework could update a Data Binding properly without ugly work around code. You would just write a generic Observable<T> : T and override that operator and you can do whatever you want. C# could even restrict you so you really must assign the value. There cant be a physical law preventing this from working
@ecreif: I am not sure what you are really asking about, but if we are still within the reality of CLI/.NET/C# I would say 'no'. Although in general It might be an interesting question; if you could think about it some more and reword it to be a question on its own here or on programmers.
@ecreif: As for your scenario: "You want to get a notification for a reference in a collection being updated/changed." I would see it more as a feature of a collection. Implement a collection with notifications and design the rest of your code to use interfaces rather than concrete collections (e.g. IList instead List, IDictionary instead Dictionary) to be able to switch to your special collection.
@ecreif: Some food for thought: What do you mean by "overloading the reference assignment operator"? What would it be overloaded over? Nothing: all assignments? Assignments of references to specific type? Static type: based on compile time reference type? Or runtime type: based on actual type of the referenced object? Or maybe you want to base it on the object that owns the reference? But do you need it? Do you want it? What about cost of runtime type checking on each assignment? What about the compiler optimising assignments out? What about reasoning about program correctness?
It was a statement. In my scenario how would you implement that observer? I want to listen to changes of the content of the collection. Looking at the logical hierarchy there is no 'entity' this change belongs to. It does not belong to the collection because the collection is not touched or resized and it doesn't belong to Observable<T> because it is not touched either. What is touched is a reference inside the collection. To get a change notification I would like to override the reference assignment operator of Observable<T>. Should be called whenever an assignment occurs.
|
8

Actually, overloading operator = would make sense if you could define classes with value semantics and allocate objects of these classes in the stack. But, in C#, you can't.

Improve this answer

9 Comments

Actually, it would make sense if you could define classes with value semantics, even if instances of such classes always had to be allocated on the heap.
@supercat: Totally agreed. But cut me a little slack: Back then I did not know languages that did value semantics better than C++.
I've never used any languages that do value semantics better than C++, and for .NET to support them anywhere near as well would require that it be much more complicated. Still, it would be helpful if there were a means by which a value type could specify that code outside the type itself should not be allowed to box or copy it; if such a thing existed, having = invoke a method in the type would then be very useful. Many things which can work with any type would be unable to work with such special types, but many kinds of mistakes could generate compile-time squawks.
In retrospect, I won't cut my past self any slack. If you need to overload the assignment operator, then the very meaning of equality is borked in your language. ML has had the correct answers regarding the meaning of equality for decades. It is unacceptable that, even today, language designers insist on being wrong.
Even if bitwise equality is sufficient to guarantee value equality, that does not imply that objects with different bit patterns shouldn't also be able to be equal. For example, if x holds a reference to one string object containing "hello" and y holds a reference to a different string object containing "hello", it may be useful to treat them as equal even though they hold references to different objects. Being able to overload an assignment operator could be useful for some types where bitwise copying would work, but might not be the best way of copying a value.
|
4

One possible explanation is that you can't do proper reference updates if you overload assignment operator. It would literally screw up semantics because when people would be expecting references to update, your = operator may as well be doing something else entirely. Not very programmer friendly.

You can use implicit and explicit to/from conversion operators to mitigate some of the seeming shortcomings of not able to overload assignment.

Improve this answer

2 Comments

ok, but that argumentation would just as well be true for overloads to Equals() or ToString() or | or ... ?
Incidentally, vb6 did allow one to effectively override the assignment operator in some cases; one would use Set xxx=yyy if one wanted reference assignment. That led to some truly hideous semantics when applied to variant types.
3

I don't think there's any really particular single reason to point to. Generally, I think the idea goes like this:

  • If your object is a big, complicated object, doing something that isn't assignment with the = operator is probably misleading.

  • If your object is a small object, you may as well make it immutable and return new copies when performing operations on it, so that the assignment operator works the way you expect out of the box (as System.String does.)

Improve this answer

Comments

3

You can overload assignment in C#. Just not on an entire object, only on members of it. You declare a property with a setter:

class Complex { public double Real { get { ... } set { /* do something with value */ } } // more members }

Now when you assign to Real, your own code runs.

The reason assignment to an object is not replaceable is because it is already defined by the language to mean something vitally important.

Improve this answer

Comments

2

It's allowed in C++ and if not careful , it can result in a lot of confusion and bug hunting.

This article explains this in great detail.

http://www.relisoft.com/book/lang/project/14value.html

Improve this answer

1 Comment

The C++ orthodox canonical form, see Coplien and Stroustrup, which requires the assignment operator for user defined types to behave robustly like built-in types, results in clean code without bugs.
1

Because shooting oneself in the foot is frowned upon.

On a more serious note one can only hope you meant comparison rather than assignment. The framework makes elaborate provision for interfering with equality/equivalence evaluation, look for "compar" in help or online with msdn.

Improve this answer

Comments

1

Being able to define special semantics for assignment operations would be useful, but only if such semantics could be applied to all situations where one storage location of a given type was copied to another. Although standard C++ implements such assignment rules, it has the luxury of requiring that all types be defined at compile time. Things get much more complicated when Reflection and and generics are added to the list.

Presently, the rules in .net specify that a storage location may be set to the default value for its type--regardless of what that type is--by zeroing out all the bytes. They further specify that any storage location can be copied to another of the same type by copying all the bytes. These rules apply to all types, including generics. Given two variables of type KeyValuePair<t1,t2>, the system can copy one to another without having to know anything but the size and alignment requirements of that type. If it were possible for t1, t2, or the type of any field within either of those types, to implement a copy constructor, code which copied one struct instance to another would have to be much more complicated.

That's not to say that such an ability offer some significant benefits--it's possible that, were a new framework being designed, the benefits of custom value assignment operators and default constructors would exceed the costs. The costs of implementation, however, would be substantial in a new framework, and likely insurmountable for an existing one.

Improve this answer

4 Comments

Who said anything about copies? operator= in C++ allows copying only a part of the state where it makes sense. Suppose you have a bounded type that clamps its values. In C++, when you assign to such a type from some numeric type, you can have the assignment do the clamping. That is impossible in C#, and a major pain; you need to use an explicit setter method. It's not possible to implement "natural" typesafe units in C# using safe code :( (well, you can, if you force the user never to do assignments!).
@KubaOber: In C++, if a templated structure type Woozle<T> contains a member of type T which overrides the assignment operator, then using the assignment operator on a Woozle<T> would cause T's assignment operator to be used on the T contained therein. The .NET Framework, however, has no mechanism for processing structure assignments recursively. Instead, it just adds up the sizes of all the structure contents plus padding, and blindly copies that many bytes. Even if C# had allowed an assignment operator to be overwritten...
...for some structure type Widget, it would not be able to override the behavior of code that copies a structure containing one, passes one to the constructor of a class that includes one, etc. Things like integer value clamping could be done with widening or narrowing conversion operators, but to support most of the purposes for which overridable assignment operators might be useful would have required that .NET separate value types into three distinct categories from the get-go: those that were simply assignable, those with virtual assignment operators, and those without...
...any assignment operators (generic type arguments of the latter form could only be used for declaring ref arguments, and would generally not be very useful without other interface constraints). I think such a design might have been workable if the product could withstand the extra time required to reach the marketplace, but I don't fault Microsoft for pushing a simpler design out the door.
1

This code is working for me:

public class Class1 { ... public static implicit operator Class1(Class2 value) { Class1 result = new Class1(); result.property = value.prop; return result; } }
Improve this answer

Comments

1

Type of Overriding Assignment

There are two type to Override Assignment:

  1. When you feel that user may miss something, and you want force user to use 'casting' like float to integer, when you loss the floating value

int a = (int)5.4f;

  1. When you want user to do that without even notice that s/he changing the object type

float f = 5;

How to Override Assignment

For 1, use of explicit keyword:

public static explicit override ToType(FromType from){ ToType to = new ToType(); to.FillFrom(from); return to; }

For 2, use of implicit keyword:

public static implicit override ToType(FromType from){ ToType to = new ToType(); to.FillFrom(from); return to; }

Update:

Note: that this implementation can take place in either the FromType or ToType class, depending on your need, there's no restriction, one of your class can hold all the conversions, and the other implements no code for this.

Improve this answer

Comments