Why must I define a commutative operator twice?
<p>I wonder if I must define a commutative operator (like <code>*</code>) twice!</p>

<pre><code>public static MyClass operator *(int i, MyClass m)
{
    return new MyClass(i * m.Value);
}

public static MyClass operator *(MyClass m, int i)
{
    return new MyClass(m.Value * i);
}
</code></pre>

<p>What's the logic behind this?</p>

<hr>

<p><strong>Additional Descriptions:</strong> Dear @Marc's answer about Vector and Matrix multiplication was good  <strong><em>if and only if we assume operand types are different !!! It's evident that we can define <code>*</code> operator only once to perform Vector or Matrix multiplication.</em></strong> So I think this is not the answer.</p>

<blockquote>
  <p>@Marc: Order is sometimes important in operators.</p>
</blockquote>

<p>Yes, but this is not equivalent with <em>Order is sometimes important in operands!</em> The above sentence may be used in case of using <code>+</code> operator before (or after) <code>*</code> operator that it will cause to different results. For example:</p>

<p><code>0 + 2 * 2 != 0 * 2 + 2</code></p>

<p>♦</p>

<p>Assume that we've defined <code>*</code> operator as:</p>

<pre><code>public static MyClass operator *(MyClass m1, MyClass m2)
{
    return new MyClass(m1.Value * m2.Value /* or some other kind of multiplication */);
}
</code></pre>

<p>We <em>can not</em> define it again.</p>

<pre><code>public static MyClass operator *(MyClass m2, MyClass m1) { ... }
</code></pre>

<p>If so, compiler would tell us that type <code>MyClass</code> already defines a member called 'op_Multiply' with the same parameter types.</p>

<p>Now, we can use this operator in two ways: <code>m1 * m2</code> or <code>m2 * m1</code> and they may have different results which depend on multiplication procedure.</p>
