如何通过重载赋值运算符给对象的部分字段赋值

[lyserver]

现有代码如下：

    public class FieldDesc<T>{
        private string _fldName = "";
        private T _fldValue;

        public FieldDesc(string name){
            _fldName = name;
        }

        public FieldDesc(T value){
            _fldValue = value;
        }

        public string fldName{
            get{return _fldName;}
            set
            {_fldName = value;}
        }

        public T fldValue{
            get{return _fldValue;}
            set{_fldValue = value;}
        }

        public override string ToString(){
            return _fldValue.ToString();
        }

        public static implicit operator FieldDesc<T>(T value){
            return new FieldDesc<T>(value);
        }
    }

    class Program{
        static void Main(string[] args){
            FieldDesc<int> UserID = new FieldDesc<int>("UserID");
            FieldDesc<string> UserName = new FieldDesc<string>("UserName");
            FieldDesc<string> Address = new FieldDesc<string>("Address");

            UserName = "张三"; //如果保留UserName的fldName属性值？？？

            Console.WriteLine(UserName.fldName);
        }
    }

问题：如何保留UserID、UserName、Address等变量的fldName属性的值？

[lyserver]

谢谢caozhy的回答，如你所说，由于.net不支持=运算符重载，无法在赋值前获得左边变量的成员，因此”“return new FieldDesc<T>(value)”语句无法将左边表达式中的fldName传递进去，我现在是以此为例，想要得到一个变通的思路。

[lyserver]

各位大牛帮帮忙啊，分不够我再加，顶者有份。

[threenewbee]

如果不怕代码龌龊，有很多变通的方法。

比如增加一个方法，使用拷贝构造函数，等等。

我的代码使用的就是直接给内侧的值赋值的办法。

[gomoku]

你直接
UserName.fldValue = "张三";
就可以了。

而且这里的运算符重载并不自然，用了反而不好。

[threenewbee]

[Quote=引用 5 楼 的回复:]
你直接
UserName.fldValue = "张三";
就可以了。

而且这里的运算符重载并不自然，用了反而不好。
[/Quote]

我在
http://topic.csdn.net/u/20120415/01/ee51f4eb-eaed-43f0-95f2-6dc5e7b70540.html
中用的就是这个方法
这和我想的完全一样 :)
不过这的确不爽。

这是C#的问题。

[threenewbee]

帮你加了100分，并且高亮，希望能有更多人提些建议。

[lyserver]

[Quote=引用 5 楼 的回复:]
你直接
UserName.fldValue = "张三";
就可以了。

而且这里的运算符重载并不自然，用了反而不好。
[/Quote]
是的重载运算符降低了运行速度，但现在不能使用UserName.fldValue = "张三"这样的语句，因为以前有大量直接使用UserName="张三"的语句，现在想兼容以前的代码。

[lyserver]

[Quote=引用 7 楼 的回复:]
帮你加了100分，并且高亮，希望能有更多人提些建议。
[/Quote]
谢谢，真诚地表示最深的谢意。
使用传参的方式，降低了代码的可读性。

[threenewbee]

江南春是VB版的高手了。

真的，现在想想，与其在C#上为了这种问题浪费时间，不如用Ruby这样更好的语言，我现在已经放弃继续研究C#了。事实上从C# 4.5来看，C#未来改进的空间在缩小。

这就如同当初用VB，使用了很多高级技巧，后来实在不能忍受了，转了C#一样。站在C#的角度看，继续研究VB是浪费时间。

[xboxeer]

我觉着好像无解 从代码层面
UserName = "张三"; 这个隐式转化本身就相当于是重新给UserName赋值 如果保留之前的UserName的属性我觉得和隐式转化这个词的语义不符合
考虑
short a=1;
int b=2;
b=a;(这里应该是有隐式转化的吧)，我们假设int有个属性intProperty，并且给他赋值3（int.intProperty=3) 在将a隐式转化为b的时候我觉得再保留这里面的intProperty属性我觉得不是很合理，本身隐式转化所有的数据就应该从被转化的那个对象里面来

[lyserver]

[Quote=引用 10 楼 的回复:]
江南春是VB版的高手了。

真的，现在想想，与其在C#上为了这种问题浪费时间，不如用Ruby这样更好的语言，我现在已经放弃继续研究C#了。事实上从C# 4.5来看，C#未来改进的空间在缩小。

这就如同当初用VB，使用了很多高级技巧，后来实在不能忍受了，转了C#一样。站在C#的角度看，继续研究VB是浪费时间。
[/Quote]
是啊，.net虽然有许多优势，但仍然存在一些缺憾，比如不能重载赋值运算符，不能继承枚举类等，虽然在2008以后增加了扩展方法、动态类型、匿名等新特点（我们公司还用的是2005）。
看来只能用另外的思路解决了。
谢谢大家，特别感谢caozhy，贴子放一天，明天结贴。

[xboxeer]

我觉着LZ可以重载+=操作符，把+操作符全部定义为fldValue的相加 对于支持+的类型就把fldValue相加，不支持的抛异常，或者重设fldValue

[anzhiqiang_touzi]

using System;
using System.Collections.Generic;
using System.Text;

namespace AnNet.Entity
{
    /// <summary>
    /// 构造一个Expression表达式对象
    /// </summary>
    public class Expression
    {
        /// <summary>
        /// 构造一个Expression对象
        /// </summary>
        /// <param name="PropertyName">属性名称</param>
        /// <param name="BaseEntityMap">实体映射</param>
        internal Expression(string PropertyName, BaseEntityMap BaseEntityMap)
        {
            this.PropertyName = PropertyName;
            this.BaseEntityMap = BaseEntityMap;
        }

        /// <summary>
        /// 实体映射
        /// </summary>
        internal BaseEntityMap BaseEntityMap = null;
        /// <summary>
        /// 名称
        /// </summary>
        string PropertyName = null;
        /// <summary>
        /// 条件
        /// </summary>
        public string Condition = "";
        /// <summary>
        /// 参数集合
        /// </summary>
        public List<EntityProperty> EntityPropertys = new List<EntityProperty>();

        private void AddExpression(Expression expression, string equals)
        {
            if (expression.EntityPropertys.Count == 0)
            {
                this.Condition = this.ToString() + " " + equals + " " + expression.ToString();
                return;
            }
            for (int i = 0; i < expression.EntityPropertys.Count; i++)
            {
                EntityProperty p = expression.EntityPropertys[i];
                //条件
                string Condition = expression.Condition;
                //参数名称
                string ParamsName = p.PropertyName;
                //新参数名称
                string _ParamsName = "p" + this.EntityPropertys.Count;

                if (this.IsExist(p.PropertyName))
                {
                    Condition = Condition.Replace("@" + ParamsName, "@" + _ParamsName);
                }
                if (equals == "=")
                {
                    this.Condition = this.ToString() + " = " + expression;
                }
                else
                {
                    this.Condition = "(" + this.Condition + ")" + " " + equals + " " + "(" + Condition + ")";
                }
                p.PropertyName = _ParamsName;
                this.EntityPropertys.Add(p);
            }
        }

        private bool IsExist(string paramsName)
        {
            foreach (EntityProperty p in this.EntityPropertys)
            {
                if (paramsName == p.PropertyName)
                {
                    return true;
                }
            }
            return false;
        }

        public static Expression operator ==(Expression compare, object Value)
        {
            if (Value is Expression)
            {
                Expression compare1 = compare;
                Expression compare2 = Value as Expression;
                compare1.AddExpression(compare2, "=");
                return compare1;
            }
            return BuildOperator(compare, Value, " = ");
        }
        public static Expression operator |(Expression compare1, Expression compare2)
        {
            compare1.AddExpression(compare2, "OR");
            return compare1;
        }
        public static Expression operator &(Expression compare1, Expression compare2)
        {
            compare1.AddExpression(compare2, "AND");
            return compare1;
        }

        public static Expression operator !=(Expression compare, object Value)
        {
            if (Value is Expression)
            {
                Expression compare1 = compare;
                Expression compare2 = Value as Expression;
                compare1.AddExpression(compare2, "<>");
                return compare1;
            }
            return BuildOperator(compare, Value, " <> ");
        }
        public static Expression operator >(Expression compare, object Value)
        {
            if (Value is Expression)
            {
                Expression compare1 = compare;
                Expression compare2 = Value as Expression;
                compare1.AddExpression(compare2, ">");
                return compare1;
            }
            return BuildOperator(compare, Value, " > ");
        }
        public static Expression operator >=(Expression compare, object Value)
        {
            if (Value is Expression)
            {
                Expression compare1 = compare;
                Expression compare2 = Value as Expression;
                compare1.AddExpression(compare2, ">=");
                return compare1;
            }
            return BuildOperator(compare, Value, " >= ");
        }
        public static Expression operator <(Expression compare, object Value)
        {
            if (Value is Expression)
            {
                Expression compare1 = compare;
                Expression compare2 = Value as Expression;
                compare1.AddExpression(compare2, "<");
                return compare1;
            }
            return BuildOperator(compare, Value, " < ");
        }
        public static Expression operator <=(Expression compare, object Value)
        {
            if (Value is Expression)
            {
                Expression compare1 = compare;
                Expression compare2 = Value as Expression;
                compare1.AddExpression(compare2, "<=");
                return compare1;
            }
            return BuildOperator(compare, Value, " <= ");
        }

        private static Expression BuildOperator(Expression compare, object Value, string operatorString)
        {
            string paramsName = "p" + compare.EntityPropertys.Count;
            //列名称
            compare.Condition += compare.ToString() + operatorString + "@" + paramsName;

            EntityProperty dp = compare.BaseEntityMap.Propertys[compare.ColumnName];

            EntityProperty property = new EntityProperty(paramsName, Value, dp.Size, dp.DbType, dp.IsPrimaryKey, dp.IsIdEntity, dp.AutoSync);
            compare.EntityPropertys.Add(property);
            return compare;
        }

        internal string ColumnName
        {
            get
            {
                string temp = this.PropertyName.Substring(this.PropertyName.IndexOf('.') + 1, this.PropertyName.Length - this.PropertyName.IndexOf('.') - 1);
                return temp;
            }
        }

        #region Override Object
        public override bool Equals(object obj)
        {
            return base.Equals(obj);
        }
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
        public override string ToString()
        {
            return this.PropertyName;
        }
        #endregion

        #region SQLFunction
        /// <summary>
        /// 求和统计
        /// </summary>
        /// <returns>求和统计属性</returns>
        public Expression Sum()
        {
            string temp = this.PropertyName.Substring(this.PropertyName.IndexOf('.') + 1, this.PropertyName.Length - this.PropertyName.IndexOf('.') - 1);
            return new Expression("SUM(" + temp + ") as " + temp + "Sum", this.BaseEntityMap);
        }

        /// <summary>
        /// 统计条数
        /// </summary>
        /// <returns>统计条数属性</returns>
        public Expression Count()
        {
            string temp = this.PropertyName.Substring(this.PropertyName.IndexOf('.') + 1, this.PropertyName.Length - this.PropertyName.IndexOf('.') - 1);
            return new Expression("COUNT(0) as " + temp + "Count", this.BaseEntityMap);
        }

        /// <summary>
        /// 求平均统计
        /// </summary>
        /// <returns>求平均统计属性</returns>
        public Expression Avg()
        {
            string temp = this.PropertyName.Substring(this.PropertyName.IndexOf('.') + 1, this.PropertyName.Length - this.PropertyName.IndexOf('.') - 1);
            return new Expression("AVG(" + temp + ") as " + temp + "Avg", this.BaseEntityMap);
        }

        /// <summary>
        /// 求最大值
        /// </summary>
        /// <returns>统计求最大值</returns>
        public Expression Max()
        {
            string temp = this.PropertyName.Substring(this.PropertyName.IndexOf('.') + 1, this.PropertyName.Length - this.PropertyName.IndexOf('.') - 1);
            return new Expression("MAX(" + temp + ") as " + temp + "Max", this.BaseEntityMap);
        }

        /// <summary>
        /// 求最小值
        /// </summary>
        /// <returns>统计求最小值</returns>
        public Expression Min()
        {
            string temp = this.PropertyName.Substring(this.PropertyName.IndexOf('.') + 1, this.PropertyName.Length - this.PropertyName.IndexOf('.') - 1);
            return new Expression("MIN(" + temp + ") as " + temp + "Min", this.BaseEntityMap);
        }
        #endregion
    }
}

是这样吗？

[crystal_lz]

- -!、、我还是来接分一个算了、、、

[以专业开发人员为伍]

[Quote=引用 2 楼 的回复:]

谢谢caozhy的回答，如你所说，由于.net不支持=运算符重载，无法在赋值前获得左边变量的成员，因此”“return new FieldDesc<T>(value)”语句无法将左边表达式中的fldName传递进去，我现在是以此为例，想要得到一个变通的思路。
[/Quote]

你可以重载 <= 晕算法啊！

[以专业开发人员为伍]

[Quote=引用 14 楼 的回复:]

我觉着LZ可以重载+=操作符
[/Quote]

跟所谓“重载=”运算符一样，根本不存在。

[xboxeer]

+=是可以重载的啊 为了看看=号到底能不能重载我还特地下了ECMA的CLI标准 =没有+=是有的
[Quote=引用 19 楼 的回复:]

引用 14 楼 的回复:

我觉着LZ可以重载+=操作符


跟所谓“重载=”运算符一样，根本不存在。
[/Quote]

[lyserver]

结贴了，实现不了这个功能，如果是原来的VB还可以通过汇编代码截持实现，VC直接支持=号重载，现在对.NET没办法，暂时改变了一下思路来实现了。

[threenewbee]

[Quote=引用 18 楼 的回复:]
引用 2 楼 的回复:

谢谢caozhy的回答，如你所说，由于.net不支持=运算符重载，无法在赋值前获得左边变量的成员，因此”“return new FieldDesc<T>(value)”语句无法将左边表达式中的fldName传递进去，我现在是以此为例，想要得到一个变通的思路。


你可以重载 <= 晕算法啊！
[/Quote]

重载 <= 运算会破坏语义吧。

[机器人]

果然是个极端的需求。从语义上说已经相当于重新构造了。要么借助另外一个容器来统一管理它们。