C#重载运算符详解

本文较为详细的描述了重载运算符的方法。一般来说,重载运算符在实际的项目开发中会经常的用到,但如果某些自定义类型通过简短几行代码重载一些常用的运算符(如:+-*/),就能让编程工作带来方便;重载运算符就是告诉编译器+-*/等运算符对于自定义类型进行什么样的操作,在代码中需要注意几点。

一、尽可能的不要改变运算符本身的含义

二、所有的运算符重载都必须声明为public和static

三、不同于扩展方法,所重载的方法必须是在被重载的类型内部,且用关键字operator

C#中的两个字符串相加,实际上是连接两个字符串,假如有两个EmployeeDetail类型相加得到一个EmployeeCollection集合,如:

EmployeeDetail a,b;

....

EmployeeCollection collection = a+b;

当编译器遇到上面的代码时就会自动调用EmployeeDetail类上标有operator +的静态方法,并将两个操作数a和b作为参数传递给对于的方法,该方法需要方法一个值赋给collection,假设EmployeeDetail类有三个属性分别是FirstName,MiddleName,LastName,还重写了ToString方法返回一个连接这三个名称的字符串,代码如:

[Serializable]
 public class EmployeeDetail
 {
   public string FirstName { get; set; }
   public string MiddleName { get; set; }
   public string LastName { set;get; }
   public override string ToString()
   {
     return string.Format("{0}{1}{2}{3}{4}", FirstName, string.IsNullOrWhiteSpace(MiddleName) ? null : "."
       , MiddleName
       , string.IsNullOrWhiteSpace(LastName) ? null : ".",
       LastName).Trim();
   }
 }

下面的代码为“+”运算符提供支持的运算符重载:

public static EmployeeCollection operator +(EmployeeDetail a, EmployeeDetail b)
{
  return new EmployeeCollection() { a, b };
}

OK,给EmployeeDetail类加上这样的一个方法之后,我们就可以像下面那个写代码了:

EmployeeCollection collection = new EmployeeDetail(){FirstName="Jackson",LastName="Bruce"} + new EmployeeDetail(){FirstName="Michael",LastName="Jackson"} ;

但是这样还不够完美,假设a,b,c都是EmployeeDetail类型,下面的代码会抛出一个编译错误:

EmployeeCollection collection = a + b + c;

为什么编译不通过呢?大家都知道除了赋值运算符外表达式是从左到右执行的,a+b返回的是EmployeeCollection类型,EmployeeCollection类型并没有重载“+”运算符,编译器不知道要执行什么操作,所以我们还有下面的两个方法:

public static EmployeeCollection operator +(EmployeeCollection collection, EmployeeDetail a)
{
  collection.Add(a);
  return collection;
}
public static EmployeeCollection operator +(EmployeeDetail a, EmployeeCollection collection)
{
  return collection + a;
}

这看起来似乎已经很完美了,但我们还可以做得更好一些,比如要将字符串“Jackson.Bruce”直接隐式转换为EmployeeDetail类型,也就是说可以将“Jackson.Bruce"这种格式的字符串直接赋给EmployeeDetail类型的对象,如:EmployeeDetail employee= “Jackson.Bruce",那么就需要重载隐式类型转换运算符了,代码如下:

/// <summary>
/// 隐式类型转换
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public static implicit operator EmployeeDetail(string name)
{
       /// 其实在这里可以写一个正则表达式检查name的字符串格式是否合法,如果不合法就抛出异常
       ///
  string[] arr;
  return string.IsNullOrWhiteSpace(name) ? null :
 new EmployeeDetail()
 {
   FirstName = (arr = name.Trim().Split('.'))[0]
   ,
   LastName = arr.Length > 1 ? arr[arr.Length > 2 ? 2 : 1] : null,
   MiddleName = arr.Length > 2 ? arr[1] : null
 };
}
public static EmployeeCollection operator +(EmployeeDetail a, string b)
{
  return new EmployeeCollection() { a, b };
}

看到这里您是不是迫不及待地想试试看,OK写个控制台程序来测试一下:

static void Main(string[] args)
{
  EmployeeDetail employee = "Jackson.Bruce";
  Console.WriteLine("FirstName={0},MiddleNam={1},LastName={2}", employee.FirstName, employee.MiddleName, employee.LastName);
  Console.WriteLine("toString={0}", employee);
  Console.WriteLine();

  EmployeeCollection collection = "Michael.Jackson" + employee;

  collection += "Bruce.Lee";
  foreach (var e in collection)
  {
 Console.WriteLine(e);
  }
  Console.WriteLine();

  collection -= employee;

  foreach (var e in collection)
  {
 Console.WriteLine(e);
  }
  Console.WriteLine("===end===");
  Console.Read();
}

运行结果如下图所示:

全部代码,里面还包含其他运算符的重载,这里就不再介绍了,赶紧动手测试一下吧:

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

namespace 重载运算符
{
  [Serializable]
  public class EmployeeDetail
  {
    public string FirstName { get; set; }
    public string MiddleName { get; set; }
    public string LastName { set;get; }
    public static EmployeeCollection operator +(EmployeeDetail a, EmployeeDetail b)
    {
      return new EmployeeCollection() { a, b };
    }

    public static EmployeeCollection operator +(EmployeeCollection collection, EmployeeDetail a)
    {
      collection.Add(a);
      return collection;
    }
    public static EmployeeCollection operator +(EmployeeDetail a, EmployeeCollection collection)
    {
      return collection + a;
    }
    /// <summary>
    /// 隐式类型转换
    /// </summary>
    /// <param name="name"></param>
    /// <returns></returns>
    public static implicit operator EmployeeDetail(string name)
    {
      string[] arr;
      return string.IsNullOrWhiteSpace(name) ? null :
        new EmployeeDetail()
        {
          FirstName = (arr = name.Trim().Split('.'))[0]
          ,
          LastName = arr.Length > 1 ? arr[arr.Length > 2 ? 2 : 1] : null,
          MiddleName = arr.Length > 2 ? arr[1] : null
        };
    }
    public static EmployeeCollection operator +(EmployeeDetail a, string b)
    {
      return new EmployeeCollection() { a, b };
    }
    public override string ToString()
    {
      return string.Format("{0}{1}{2}{3}{4}", FirstName, string.IsNullOrWhiteSpace(MiddleName) ? null : "."
        , MiddleName
        , string.IsNullOrWhiteSpace(LastName) ? null : ".",
        LastName).Trim();
    }
  }
  public class EmployeeCollection : List<EmployeeDetail>
  {
    public static EmployeeCollection operator +(EmployeeCollection a, string b)
    {
      a.Add(b);
      return a;
    }
    public static EmployeeCollection operator +(string b, EmployeeCollection a)
    {
      return a + b;
    }

    public static EmployeeCollection operator -(EmployeeCollection a, EmployeeDetail b)
    {
      a.Remove(b);
      return a;
    }
  }

  class Program
  {
    static void Main(string[] args)
    {
      EmployeeDetail employee = "Jackson.Bruce";
      Console.WriteLine("FirstName={0},MiddleNam={1},LastName={2}", employee.FirstName, employee.MiddleName, employee.LastName);
      Console.WriteLine("toString={0}", employee);
      Console.WriteLine();

      EmployeeCollection collection = "Michael.Jackson" + employee;

      collection += "Bruce.Lee";
      foreach (var e in collection)
      {
        Console.WriteLine(e);
      }
      Console.WriteLine();

      collection -= employee;

      foreach (var e in collection)
      {
        Console.WriteLine(e);
      }

      Console.WriteLine("===end===");
      Console.Read();
    }
  }
}
(0)

相关推荐

  • c#重写TabControl控件实现关闭按钮的方法

    1.c#里面的TabControl控件没有关闭按钮,而且很难看. 2.有一些已经做好的第三方控件,但是收费. 3.由于我的故障树推理诊断项目在绘图的时候允许同时打开多个文档进行操作,就要实现类似于浏览器的多标签功能,而且要可以关闭. 4.所以自己写一个类继承TabControl类,然后重写一些里面的方法即可实现. 5.特色:有关闭按钮,标签有背景颜色,选中的标签和没选中的颜色不一样,实现鼠标中键和右键的功能 先看我的项目中的完整代码,有很多代码是我的项目需要,可根据你的项目需求删减,核心的代码后

  • C#中多态、重载、重写区别分析

    本文实例总结了C#中多态.重载与重写的概念与区别.对于初学C#的朋友来说有不错的参考价值.分享给大家供大家参考.具体分析如下: 重写:是指重写基类的方法,在基类中的方法必须有修饰符virtual,而在子类的方法中必须指明override. 格式如下: 1.在基类中: public virtual void myMethod() { } 2.在子类中: public override void myMethod() { } 重写以后,用基类对象和子类对象访问myMethod()方法,结果都是访问在

  • 基于C#方法重载的总结详解

    1.首先解释一下什么是方法重载? 方法重载是指在同一个类中方法同名,参数不同,调用时根据实参的形式,选择与他匹配的方法执行操作的一种技术. 这里所说的参数不同是指以下几种情况: ①  参数的类型不同 ②  参数的个数不同 ③  参数的个数相同时他们的先后顺序不同 注意:系统会认为是同一个方法的两种情况,这样的两个方法不可以在同一个类里,否则系统会报错. ⑴返回类型不同,方法名和参数个数.顺序.类型都相同的两个方法 ⑵返回类型相同,方法名和参数的个数.顺序.类型都相同的两个方法,但是参数的名字不同

  • c#方法重写和隐藏的学习示例

    最近正在学习c#,对其中的方法重写和隐藏的概念很是模糊,现在将其归纳如下: 1:方法重写:就是在基类中的方法用virtual关键字来标识,然后在继承类中对该类进行重写(override),这样基类中的方法已经被重写了,已经失去了功能了.当让基类的对象的引用直接指向继承类的对象时(多态性),调用该方法则是调用的继承类的方法. 2:方法隐藏:无论基类中的方法是否用了virtual关键字,继承类中都可以用new关键字(如果不用new的话,不会产生错误,但会生成一个编译警告)将基类中的方法隐藏,所谓隐藏

  • C#中重载相等(==)运算符示例

    运算符重载一直是一个很诡异事情,因为在写代码的时候,不知道某个运算符有没有被重载过.在 C++ 里面,运算符重载可以写在类的外面,当 intellisense 不工作的时候,找到一个运算符的重载函数是一件相当头疼的事情.这个问题在 C# 中改善了不少,因为运算符重载一定要写在类内,而且 intellisense 很强大.不过另一个问题又产生了-- 先来看 C++ 中的"=="重载: struct A{ int x; int y; }; inline bool operator == (

  • C#通过重写Panel改变边框颜色与宽度的方法

    本文实例讲述了C#通过重写Panel改变边框颜色与宽度的方法.分享给大家供大家参考.具体实现方法如下: using System; using System.Collections.Generic; using System.Text; using System.Runtime.InteropServices; using System.ComponentModel; using System.Windows.Forms; using System.Drawing; namespace Imag

  • C#运算符重载用法实例分析

    本文实例讲述了C#运算符重载用法.分享给大家供大家参考.具体分析如下: public class Plane { public virtual double TopSpeed() { return 300.0D;} public static bool operator>(Plane one, Plane two) { return one.TopSpeed() > two.TopSpeed(); } public static bool operator<(Plane one, Pla

  • C#中重载与重写区别分析

    一.前言        接触面向对象的思想已经有一段时光了,为什么要学习面向对象呢?因为面向对象具有可复用性.可维护性.可扩展性等优点.         本人之前一直接触的是VB语言,所以正式接触面向对象的编程语言还要从C#开始.前段时间,刚学完C#,其中重载.重写傻傻分不清楚.如今通过查阅资料对这两者有了一个大概的理解,不足之处还请多多指教. 二.定义         重载:在同一定义域内(比如一个类里面).方法名相同,参数个数.次序.类型不同.因此重载对返回值没有要求,可以相同,也可以不同.

  • c# 重载WndProc,实现重写“最小化”的实现方法

    code #1 复制代码 代码如下: private void Form1_SizeChanged(object sender, EventArgs e) //最小化隐藏窗体 { if (this.WindowState == FormWindowState.Minimized)//窗体状态为最小化 { StopRectTimer.Enabled = false; this.Visible = false; this.notifyIcon1.Visible = true; //显示系统托盘图标

  • C#重载运算符详解

    本文较为详细的描述了重载运算符的方法.一般来说,重载运算符在实际的项目开发中会经常的用到,但如果某些自定义类型通过简短几行代码重载一些常用的运算符(如:+-*/),就能让编程工作带来方便:重载运算符就是告诉编译器+-*/等运算符对于自定义类型进行什么样的操作,在代码中需要注意几点. 一.尽可能的不要改变运算符本身的含义 二.所有的运算符重载都必须声明为public和static 三.不同于扩展方法,所重载的方法必须是在被重载的类型内部,且用关键字operator C#中的两个字符串相加,实际上是

  • python接口,继承,重载运算符详解

    目录 1. 序列__getitem__ 2. __setitem__ 3. 抽象基类 4. 不要直接子类化内置类型 5. 继承顺序 6. 重载运算符 总结 1. 序列__getitem__ 如果没有 __iter__ 和 __contains__ 方法, Python 会调用 __getitem__ 方法, 设法让 迭代 和 in 运算符可用 class Foo: def __getitem__(self, pos): return range(0, 30, 10)[pos] f = Foo()

  • 基于C++ bitset常用函数及运算符(详解)

    C++ bitset--高端压位卡常题必备STL ------------------------------------------------------------ 以下内容翻译自cplusplus.com,极大地锻炼了我的英语能力. bitset存储二进制数位. bitset就像一个bool类型的数组一样,但是有空间优化--bitset中的一个元素一般只占1 bit,相当于一个char元素所占空间的八分之一. bitset中的每个元素都能单独被访问,例如对于一个叫做foo的bitset,

  • JavaScript知识点总结(四)之逻辑OR运算符详解

    在JavaScript中,逻辑OR运算符用||表示 var bTrue = true; var bFalse = false; var bResult = bTrue || bFalse; 下面的真值表描述了逻辑AND运算符的行为: 在JavaScript中,0,"",false,null,undefined,NaN均表示false, 可以用如下的代码证明: <script type="text/javascript"> var bFalse = fal

  • PHP读书笔记_运算符详解

    什么是运算符 什么是运算符?运算符是告诉PHP做相关运算的标识符号.例如,你需要计算123乘以456等于多少,这时候就需要一个符号,告诉服务器,你需要做乘法运算. PHP中的运算符有哪些?PHP运算符一般分为算术运算符.赋值运算符.比较运算符.三元运算符.逻辑运算符.字符串连接运算符.错误控制运算符. PHP中的算术运算符 算术运算符主要是用于进行算术运算的,例如:加法运算.减法运算.乘法运算.除法运算.在PHP中的常用的算术运算符对应下表: PHP中的赋值运算符 PHP的赋值运算符有两种,分别

  • C++位运算符详解(异或运算符和移位运算符)

    什么是位运算 位运算符按二进制进行运算,这些运算符只能用于整数类型的操作.如:char,short,int,long 通过位运算符来获取高位值和低位值 int a=0x1234; int high,low; high = (a>>8) &0x00ff; low = a & 0x00ff; 左移运算符和右移运算符(<<和>>) 左移是将一个二进制数,移动若干位,右边空出的位置用0来填补,高位左移溢出应该舍弃该高位. 如:inta = 8, a = 0000

  • C++中函数重载实例详解

    C++中函数重载实例详解 函数重载: 1.具有相同的名称,执行基本相同的操作,但是使用不同的参数列表. 2.函数具有多态性. 3.编译器通过调用时参数的个数和类型确定调用重载函数的哪个定义. 4.只有对不同的数据集完成基本相同任务的函数才应重载. 函数重载的优 点 1.不必使用不同的函数名 2.有助于理解和调试代码 3.易于维护代码 接下来直接上代码: #include <iostream> using namespace std ; void say_hello(void) { cout &

  • 为IObservable实现自己的运算符(详解)

    您可以通过为LINQ库不提供的操作添加新运算符,或者通过创建自己的标准查询运算符实现来提高可读性和性能,从而扩展Rx. 编写自定义版本的标准LINQ操作符在您希望使用内存中对象操作时以及当预期自定义不需要查询的全面视图时非常有用. 创建新操作符 LINQ提供了一整套操作符,涵盖了一组实体上的大多数可能的操作. 但是,您可能需要一个运算符为查询添加特定的语义,尤其是如果您可以在代码中多次重复使用该运算符. 许多现有的LINQ运算符实际上是使用其他基本LINQ运算符构建的. 例如,SelectMan

  • 对Python3 * 和 ** 运算符详解

    在 Python 中,* 和 ** 具有语法多义性,具体来说是有四类用法. 1. 算数运算 * 代表乘法 ** 代表乘方 >>> 2 * 5 10 >>> 2 ** 5 32 2. 函数形参 *args 和 **kwargs 主要用于函数定义. 你可以将不定数量的参数传递给一个函数.不定的意思是:预先并不知道, 函数使用者会传递多少个参数给你, 所以在这个场景下使用这两个关键字.其实并不是必须写成 *args 和 **kwargs. *(星号) 才是必须的. 你也可以写

  • HashMap源码中的位运算符&详解

    引言 最近在读HashMap源码的时候,发现在很多运算符替代常规运算符的现象.比如说用hash & (table.length-1) 来替代取模运算hash&(table.length):用if((e.hash & oldCap) == 0)判断扩容后元素的位置等等. 1.取模运算符%底层原理 ​总所周知,位运算&直接对二进制进行运算:而对于取模运算符%:a % b 相当于 a - a / b * b,底层实际上是除法器,究其根源也是由底层的减法和加法共同完成.所以其运行效

随机推荐