Save Time and Effort by Overloading Operators.

Category:

C#, VB.NET, ASP.NET

Type:

Classes

Difficulty:

Beginning

Author: Anonymous

Version Compatibility: Visual Basic.NET

More information:

This has to be one of the coolest things I've stumbled across in my transition from VB6 to VB.NET-- overloading operators. Fundamentally, it means to add an operator procedure to your class or structure to indicate how an operation should be performed, and you can overload them multiple times in your class, if need be. Each version must have unique parameters, one of which must be the type of your class. The Pixel32 structure submitted is a nice example of how operator overloading can save time and effort.

Instructions: Copy the declarations and code below and paste directly into your VB project.

Declarations:
' (None)

Code:

' FreeVBCode.Pixel32.vb

Namespace FreeVBCode

''' <summary>
   ''' Represents a 32-bit color pixel.
   ''' </summary>
   ''' <remarks>
   ''' Written Feb 05 2006 by
   ''' M_i_c_h_a_e_l__A__S_e_e_l
   ''' (m_s_e_e_l_1_9_7_6_[at]_g_m_a_i_l_[dot]_c_o_m),
   ''' Free for all use
   ''' </remarks>
   Public Structure Pixel32

''' <summary>
      ''' The blue channel of this instance.
      ''' </summary>
      Public Blue As Byte

''' <summary>
      ''' The green channel of this instance.
      ''' </summary>
      Public Green As Byte

''' <summary>
      ''' The red channel of this instance.
      ''' </summary>
      Public Red As Byte

''' <summary>
      ''' The alpha channel of this instance.
      ''' </summary>
      Public Alpha As Byte

''' <summary>
      ''' Creates a new pixel instance.
      ''' </summary>
      ''' <param name="red">The red channel of the new instance.</param>
      ''' <param name="green">The green channel of the new instance.</param>
      ''' <param name="blue">The blue channel of the new instance.</param>
      ''' <param name="alpha">The alpha channel of the new instance.</param>
      Public Sub New(ByVal red As Byte, ByVal green As Byte, ByVal blue As Byte, Optional ByVal alpha As Byte = 255)
         With Me
            .Blue = blue
            .Green = green
            .Red = red
            .Alpha = 255
         End With
      End Sub

''' <summary>
      ''' Returns a greyscale copy of this pixel. Default amounts are ITU standard.
      ''' </summary>
      ''' <param name="redAmount">The amount of red to include in the grey value. (The amounts summed should equal 1.0F, but 0.0F to 1.0F is valid.)</param>
      ''' <param name="greenAmount">The amount of green to include in the grey value. (The amounts summed should equal 1.0F, but 0.0F to 1.0F is valid.)</param>
      ''' <param name="blueAmount">The amount of blue to include in the grey value. (The amounts summed should equal 1.0F, but 0.0F to 1.0F is valid.)</param>
      Public Function Greyscale(Optional ByVal redAmount As Single = 0.222, Optional ByVal greenAmount As Single = 0.707, Optional ByVal blueAmount As Single = 0.071) As Pixel32
         With Me
            Dim btGrey As Byte = CByte((.Red * redAmount) + (.Green * greenAmount) + (.Blue * blueAmount))
            Return New Pixel32(btGrey, btGrey, btGrey, .Alpha)
         End With
      End Function

''' <summary>
      ''' Returns the result of blending this instance over the destination at the specified opacity.
      ''' </summary>
      ''' <param name="destination">The pixel upon which to blend this instance.</param>
      ''' <param name="Opacity">The opacity at which to perform the blend. This is in addition to existing alpha channels.</param>
      Public Function Blend(ByVal destination As Pixel32, Optional ByVal Opacity As Byte = 255) As Pixel32
         Dim pxRet As Pixel32 = Me
         With pxRet
            Dim fSrc As Single = CSng((.Alpha / 255) * (Opacity / 255))
            Dim fDst As Single = 1 - fSrc
            .Blue = CByte((.Blue * fSrc) + (destination.Blue * fDst))
            .Green = CByte((.Green * fSrc) + (destination.Green * fDst))
            .Red = CByte((.Red * fSrc) + (destination.Red * fDst))
            .Alpha = CByte(destination.Alpha + ((255 - destination.Alpha) * fSrc))
         End With
         Return pxRet
      End Function

''' <summary>
      ''' Converts an instance of Pixel32 to an instance of Color.
      ''' </summary>
      Public Shared Widening Operator CType(ByVal px As Pixel32) As Color
         With px
            Return Color.FromArgb(.Alpha, .Red, .Green, .Blue)
         End With
      End Operator

''' <summary>
      ''' Converts an instance of Pixel32 to a 32-bit signed integer.
      ''' </summary>
      Public Shared Widening Operator CType(ByVal px As Pixel32) As Integer
         With px
            Return Color.FromArgb(.Alpha, .Red, .Green, .Blue).ToArgb()
         End With
      End Operator

''' <summary>
      ''' Converts an instance of Color to an instance of Pixel32.
      ''' </summary>
      Public Shared Widening Operator CType(ByVal c As Color) As Pixel32
         With c
            Return New Pixel32(.R, .G, .B, .A)
         End With
      End Operator

''' <summary>
      ''' Converts a 32-bit signed integer to an instance of Pixel32.
      ''' </summary>
      Public Shared Widening Operator CType(ByVal i As Integer) As Pixel32
         With Color.FromArgb(i)
            Return New Pixel32(.R, .G, .B, .A)
         End With
      End Operator

End Structure

End Namespace