How to format a Byte Enum as a hexnumber on the Editor Tooltip or Intellisense?

Question

5.00/5 (2 votes)

See more:

Hi,

I'm trying to figure out how do I display or set the format of my enum to hex on the Editor Tooltip or Intellisense? I'm building a reusable class and I want the hex numbers to show up, instead of the decimal, when referencing the enum within the VB.NET editor.

Here is one of my enums:

VB

Public Enum OutputPort As Byte
    PortA = &H0&
    PortB = &H1&
    PortC = &H2&
    AllPorts = &HFF&
End Enum

For instance, when I type the following in VB.NET OutputPort.a

An autocomplete box comes up, if you hover over the "AllPorts" enum entry, a white info box (Editor tooltip or intellisense) appears that says "OutputPort.AllPorts = 255". Is there a way to get it to display "OutputPort.AllPorts = &HFF&" or equivalent so that the developer gets the hex code instead?

This is just one example of many byte enums that have to be formatted in hex. I'm hoping for some sort of .NET formatting property, instead of commenting each enumerated value.

I want to remember that I have seen this before somewhere, but I'm a bit rusty on the correct terminology, so I have been unable to find useful results in Google.

Thanks,

Marco

[The article providing comprehensive answer to the questions on this page is published: Bitwise Enumeration Editor for PropertyGrid and Visual Studio[^] — SA]

Posted 13-Aug-14 19:52pm

bigbro_1985

Updated 19-Aug-14 19:16pm

Sergey Alexandrovich Kryukov

v5

Add a Solution

Comments

Sergey Alexandrovich Kryukov 20-Aug-14 1:20am

The article I promised is published: Bitwise Enumeration Editor for PropertyGrid and Visual Studio. It should answer nearly all questions we discussed on this page, in addition the the other answers and articles I references.

Besides, I decided to up-vote this question post (not even for the question, but for all the discussion) with my 5. I also credited you in the section "Gredits" of my article for the raising some question which gave me some ideas and inspired doing this work. Thank you!

I hope you will find this work interesting and useful.

—SA

3 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

CPallini · Accepted Answer · 2014-08-13T23:45:00

Solution 2

As far as I know you cannot do that in Visual Studio IDE (maybe I am wrong).

Simple solution: make the developers learning hexadecimal numbers, after all it is a useful piece of knowledge.

A workaround: use the string representation of the hexadecimal numbers, and convert them to their byte values before actually sending it to the device.

Posted 13-Aug-14 23:45pm

CPallini

Comments

Sergey Alexandrovich Kryukov 17-Aug-14 4:30am

I agree and expressed similar opinion. But, later on, I came to a good alternative. I implemented a bitwise enumeration editor which can be used in EditorAttribute of any enumeration type. This is the mechanism which allows any PropertyGrid to show this editor. Including the PropertyGrid used in Visual Studio. And, in the editor, two strings are shown: enumeration member (with an alternative to get human-readable representation from resource) and ToolTip of the node shows a long "description" string defined in resource.

I just completed the implementation: such enumeration types, augmented with appropriate attributes, really show those extra strings in Visual Studio. Pretty interesting. Please see my comments to Solution 1 at the end of comment tree.

—SA

Sergey Alexandrovich Kryukov · Accepted Answer · 2014-08-16T21:40:00

bigbro_1985 wrote:
But I think you just answered another problem that I had, or gave me an idea rather. I actually wanted a bitwise enumeration to assign Booleans, right now I made a bitwise structure that converts the 8 bit Boolean value to byte. But I don't like what I did, it doesn't look clean to me. This is what I like about embedded development because you get all your bitwise operators.

Oh, this is another problem I solved a while ago. The solution is really comprehensive. Please see my first article from my short "enumeration" series: Enumeration Types do not Enumerate! Working around .NET and Language Limitations[^].

This article solves a set of different related problems at once, first of all, the problem is using foreach for enumerations (it's a shame that it is not done in .NET by default), and a pretty tricky problems if members with identical underlying integer values.

And one of the problems is the "bitwise" operations. My solution is two-fold: first I explain how to work "manually", in the section "2 Background: Life before Enumeration Class", subsection: "2.4 Iterating Bit Sets". And later on, I explain the advances brought by my generic class "Enumeration". So, you will have a choice and may decide to use the simple technique, if it's enough for you.

[EDIT]

It's possible that you cannot figure out how to read/assign bits as Boolean. Let's do it: you read my article, and here I'll explain the rest, about Boolean. The idea is to use indexed property:

C#

public enum OptionSet {
    None = 0,
    AlignX = 1 << 0,
    AlignY = 1 << 1, // this is better than 1, 2, 4, 8...
    Transparent = 1 << 2,
    Border = 1 << 3,       
} //enum OptionSet

public class SomeContainerWithEnumerationProperty {

    OptionSet optionSet; // data is here

    public bool this[OptionSet index] {
        get {
            // read bit depending on index
            // and return (bit is set) boolean value
        }
        set {
            // set the bit,
            // depending on index and boolean value
        }
    }

} //class SomeContainerWithEnumerationProperty

//... usage:

SomeContainerWithEnumerationProperty myOptions =
   new SomeContainerWithEnumerationProperty();

myOptions[OptionSet.Border] = true; // set one bit
myOptions[OptionSet.AlignX | OptionSet.AlignX] = true; // set 2 bits at once

//...

myOptions[OptionSet.AlignX] = false; // clear one bit

I hope you got it. Some a bit tricky problem is: in this syntax, you can have only one such property. Can you have more than one? In principle, if property type is always bool, but the types if index different (different enum types or other different types), the compiler can resolve which one to use, but how to write it?

The idea is: put these properties in one or more separate interfaces and make your class implement all these interfaces, with explicit interface implementation syntax. So, one property is "this" of the class itself, as shown above, plus one or more coming from the implementation of interfaces.

—SA

Sergey Alexandrovich Kryukov · Accepted Answer · 2014-08-13T20:33:00

Solution 1

Not a problem at all. You take enumeration underlined integer value by taking a value of a enumeration variable and casting it to byte (in your case). And them you format this byte as hexadecimal, using byte.ToString(string format) with format string "X", or "x" or, say, "X2":
http://msdn.microsoft.com/en-us/library/y11056e9%28v=vs.110%29.aspx[^],
http://msdn.microsoft.com/en-us/library/dwhawy9k%28v=vs.110%29.aspx[^].

—SA

Posted 13-Aug-14 20:33pm

Sergey Alexandrovich Kryukov

Comments

[no name] 14-Aug-14 2:49am

Hi SA,

Yes, I understand casting the variable to string and formatting it to be hex. I have used byte.ToString("X2") before and I have gotten that to work just fine.

What I would like is, when I make a reference to the enum somewhere else in my code or in a new project and I hover over "OutputPort.AllPorts" I don't want the editor tooltip text to display "OutputPort.AllPorts = 255", I would like it to display "OutputPort.AllPorts = &HFF&".

Because I'm building a serial communication class and the device I'm communicating accepts commands in HEX, it would match up with manuals and aid debugging.

Thanks,

Sergey Alexandrovich Kryukov 14-Aug-14 2:53am

What project? Do you mean behavior in IDE, Visual Studio? If so, who cares what it shows? It's not your IDE anyway...
—SA

[no name] 14-Aug-14 3:47am

LOL, yes. Visual Studio, in the VB.NET editor. I know its not my IDE, but this class is intended for other people using this specific device, which I'm posting up on code project in the next couple of weeks. As soon as I'm done testing/documenting/tidying up.

I would like it if the end developers passed a Hex command to the device from my class in VB.Net or C# (while using the command enum), they can see the HEX value as a pose to the decimal value so that you don't need to go pull out a calculator or do long division to verify the correct command is being sent. See these hex commands are listed in the device's Bluetooth communication manual in HEX and not decimal. I'm sure everyone else will care who uses this because it would be thorough documentation.

I know you can place the following code to add information to the editor tooltip text.


 ''' <summary>
 ''' Description goes here
 ''' 
 ''' <value></value>
 ''' <returns></returns>
 ''' <remarks></remarks>

Right now I have tested this, it works, but its a pain, and will be a major pain to do this to each and every enumerated value. And then it still displays the value in the bottom in decimal.


    ''' <summary>
    ''' Specifies the Motor Regulation Mode Command values in HEX
    ''' </summary>
    ''' <remarks></remarks>
    Public Enum MotorRegulationMode As Byte
        ''' <summary>Disabled = &H0&.  Regulation Will Be Disbled:  Use this value if the Motor mode value is 0x00 (Coast mode), 0x01 (Motor ON mode) or 0x03 (Motor ON with Break mode).</summary>
        Disabled = &H0&

        ''' <summary>SpeedRegulationMode = &H1&.  Speed Regulation:  Use this regulation mode if the Motor mode value is 0x05 (Motor ON and Regulated mode) or 0x07 (Motor ON with Break and Regulated mode), and you would like the NXT firmware automatically adjust the speed to the specified motor power set point value no matter the physical overload on the motor.</summary>
        SpeedRegulationMode = &H1&

        ''' <summary>SynchronizationMode = &H2&.  Two Motors Synchronization Regulation:  Use this regulation mode if the Motor mode value is 0x05 (Motor ON and Regulated mode) or 0x07 (Motor ON with Break and Regulated mode), and you would like the NXT firmware automatically keep the two motors in sync regardless of varying physical loads.</summary>
        SynchronizationMode = &H2&
    End Enum

What do I do to modify the enum's value displayed on the editor tooltip from decimal to hex? Is it even possible?

I don't know if I'm making sense, sorry I don't know all the correct terminology of what I'm trying to achieve.

Sergey Alexandrovich Kryukov 14-Aug-14 6:49am

First, I would not solve this problem at all; second, it looks like you are confused fundamentally. The key is "modify the enum's value displayed". It's not "modify". It sounds like 255 should be modified into &HFF&. But it's not "modified". This is the same value. I guess you understand it, it could be just bad wording. It's format should be "modified". But format is not a part of enumeration. This is a part of Visual Studio. Besides, why not "0xFF"? Visual Studio works the same way will all .NET languages.

By the way, you can modify the way the value is edited in PropertyGrid. For this purpose, you need to supply a different editor and prescribe this editor in a type attribute for your enumeration type. And yes, it should be shown in IDE then. This is possible, but even this would be a bad thing. Come on, what is shown in Visual Studio is shown for developers. Do you really think that anyone won't see that &HFF& is 255? From the other hand, isn't that natural to have the same treatment for all enumeration types? Besides, people should work with enumeration member names, not values. Look at all MSDN documentation.

In other words, what you want is unreasonable. I don't think you can modify the tooltip in the IDE.

—SA

CPallini 14-Aug-14 5:29am

5.

Sergey Alexandrovich Kryukov 14-Aug-14 6:50am

Thank you, Carlo. It looks like OP wanted something very different; please see above.
—SA

Sergey Alexandrovich Kryukov 20-Aug-14 1:22am

I published the article I promised: Bitwise Enumeration Editor for PropertyGrid and Visual Studio. Hope you'll find it interesting.
—SA

[no name] 14-Aug-14 8:56am

Thanks, believe me I completely agree with you. In fact as an electronic engineer, I prefer the 0xFF format, it just comes more naturally than &HFF&. I personally know the difference between hex and dec and I know that while working with these commands. I enumerated them to organize the constants and generally simplify my own life.

I studied mostly embedded programming and tought my self VB.NET, and English is my second language so please excuse the incorrect terminology.

I thought that I have seen this happen in a class that I used somewhere along the line, but I guess not.

Thanks for your time!

Sergey Alexandrovich Kryukov 14-Aug-14 9:29am

First of all, I am sorry if, by some reason, I made incorrect assumptions of your understanding of some of the issues. From time to time, it just happens, sometime based on miscommunications or something else. As I say, I did not mean to be positive, but I needed to clarify it, to establish clear communication.

Let's try to draw a line. You can modify the behavior of Visual Studio using Visual Studio add-ons. Keyword here is "add", as opposed to modify. I mean, if you add some processing in the IDE, you can generate some different string representation of something, but generally you cannot modify it in the existing action.

Even the PropertyGrid behavior: you can modify it by using specific editor you define for your type, but you actually don't modify any existing controls, you add one of your own (in this case, you don't have to write a new add-on). That's why I believe it's impossible to modify some tooltip text.

So, if you want, I can explain this PropertyGrid thing, but this is not what you were asking about. Besides, I have 3 CodeProject articles on enumerations, deeper ones, and one of them is on presentation, which can be very useful, but mostly for general software development.

Other than that (let me know if you need this information), I would suggest you accept my answer formally (green "Accept" button) to close the issue. (It won't prevent others to add more answers, if someone thinks I was wrong.)

—SA

Sergey Alexandrovich Kryukov 14-Aug-14 9:54am

Wait a second, just got a good idea for you!

This is based on the above. The best way to solve a poorly solvable problem is not to solve it, but solve a more general problem instead. Here is what you need: this is all can be really useful only for a bitwise enumeration type. Therefore, create a GridView bitwise enumeration editor.

You really need to write a GridView editor with human-readable configurable names of enumeration members, showing a check box for each bit (you will also need to add an attribute to hide some of the members from this editor). Then this editor will be shown in any PropertyGrid, even in Visual Studio (without writing any add-ons!).

If you do that, the tooltip will be simply insignificant.

—SA

[no name] 17-Aug-14 2:44am

Hi SA,

Thanks for the help, much appreciated. I will definitely remember the correct terminology for next time, its all a learning experience after all.

I feel you're completely right and I'll just leave this as is and not solve it. If someone complains about it, I'll tell them to just be grateful I took the time to make, explain, and posting it. If they want to changed it, they should feel free to change it and repost it.

But I think you just answered another problem that I had, or gave me an idea rather. I actually wanted a bitwise enumeration to assign Booleans, right now I made a bitwise structure that converts the 8 bit Boolean value to byte. But I don't like what I did, it doesn't look clean to me. This is what I like about embedded development because you get all your bitwise operators.

Answer accepted, 5*, and thanks again for taking the time to clarify!

Sergey Alexandrovich Kryukov 17-Aug-14 3:32am

Some good news for you:

I decided to write an article on the topic. All the problems are already solved, but writing such editor is a serious problem.
I also addressed the ToolTip shown in the editor: you can add human-readable names for resources and include your hex value if it helps.

For example, you can add resource with the key "SynchronizationMode" with the value "Synchronization Mode".
You can add another resource where the key "SynchronizationMode" points to the value, say, "SynchronizationMode (&H2&)".
Then first string is shown in the editor (check box for bitwise editor, node without checkbox — for "usual" enum editor);
and the second value can be shown in the ToolTip (alternative, longer name).

This is invoked when you add a special attributes: editor attributes to the enum type, and "DisplayName" and "Description" attributes for either enumeration type or separate enum member.

Now, you can learn how it works even now, if you read my article: http://www.codeproject.com/Articles/136181/Human-readable-Enumeration-Meta-data.

The only difference is: in that article, you need to use my library to "visualize" those strings. Therefore, it cannot be simply embedded in Visual Studio. In my new work derived from that one, this is done: Visual Studio will "see" those strings, because I created and embedded this "human-readable" naming using EditorAttribute, which is a standard way which Visual Studio does use in the standard PropertyGrid (for example, in Visual Studio "Properties" window). In this window, you will see both "human-readable" names of enumeration types using those attributes and "description" strings in the ToolTips. (By the way, you are the one who gave me the idea of using ToolTips; they are already embedded in TreeNode I use in the editor UI. Thank you!).

I just completed the full code, with clear sample project demonstrating it all. I'll try to publish it soon. In the meanwhile, please see the code of the article I referenced above.

—SA

How to format a Byte Enum as a hexnumber on the Editor Tooltip or Intellisense?

3 solutions

Solution 2

Solution 3

Solution 1

Add your solution here

Preview 0

Existing Members

...or Join us