Improve Developer Experience

[TonyValenti]

@sbwalker Do you support having classes decorated such that they provide more useful debugger display information?

[TonyValenti]

@sbwalker - If approved, I'll do the following:

1. Add this code into Oqtane.Shared under the namespace 'Oqtane.Diagnostics':

    [DebuggerDisplay(DisplayBuilder.DebuggerDisplay)]
    public class DisplayBuilder {
        public const string DebuggerDisplay = "{GetDebuggerDisplay(),nq}";

        public static DisplayBuilder Create() {
            return new DisplayBuilder();
        }


        protected List<String> IDs { get; private set; } = new List<string>();
        protected List<String> Types { get; private set; } = new List<string>();
        protected List<String> Prefixes { get; private set; } = new List<string>();
        protected List<String> Datas { get; private set; } = new List<string>();
        protected List<String> Suffixes { get; private set; } = new List<string>();

        public DisplayBuilder ID(params object[] Values) {
            IDs.AddRange(Values.Select(x => x.ToString()));
            return this;
        }

        public DisplayBuilder Type(params Type[] Values) {
            Types.AddRange(Values.Select(x => x.Name));
            return this;
        }

        public DisplayBuilder TypeOf(params object[] Values) {
            Types.AddRange(Values.Select(x => x.GetType().Name));
            return this;
        }

        public DisplayBuilder TypeOf<T>() {
            return Type(typeof(T));
        }


        public DisplayBuilder Prefix(params object[] Values) {
            Prefixes.AddRange(Values.Select(x => x.ToString()));
            return this;
        }

        public DisplayBuilder Data(params object[] Values) {
            Datas.AddRange(Values.Select(x => x.ToString()));
            return this;
        }

        public DisplayBuilder Suffix(params object[] Values) {
            Suffixes.AddRange(Values.Select(x => x.ToString()));
            return this;
        }

        public DisplayBuilder Enabled(bool Value) {
            return Prefix(!Value ? "Disabled" : "");
        }

        public DisplayBuilder Visible(bool Value) {
            return Prefix(!Value ? "Hidden" : "");
        }

        public DisplayBuilder Redacted(bool Value) {
            return Prefix(Value ? "Redacted" : "");
        }

        public DisplayBuilder Default(bool Value) {
            return Prefix(Value ? "Default" : "");
        }

        public virtual string GetDebuggerDisplay() {
            var Parts = new List<String>();

            {
                var Values = Join(IDs);
                if (!string.IsNullOrWhiteSpace(Values)) {
                    Parts.Add($@"[{Values}]");
                }
            }

            {
                var Values = Join(Types);
                if (!string.IsNullOrWhiteSpace(Values)) {
                    Parts.Add($@"<{Values}>");
                }
            }

            {
                var Values = Join(Prefixes);
                if (!string.IsNullOrWhiteSpace(Values)) {
                    Parts.Add($@"({Values})");
                }
            }

            {
                var Values = Join(Datas);
                if (!string.IsNullOrWhiteSpace(Values)) {
                    Parts.Add($@"{Values}");
                }
            }

            {
                var Values = Join(Suffixes);
                if (!string.IsNullOrWhiteSpace(Values)) {
                    Parts.Add($@"({Values})");
                }
            }

            var ret = string.Join(" ", Parts);

            return ret;
        }

        private static string Join(IEnumerable<string> Values) {
            var Separator = " - ";
            var ret = string.Join(Separator, from x in Values where !string.IsNullOrWhiteSpace(x) select x);

            return ret;
        }


        public override string ToString() {
            return GetDebuggerDisplay();
        }

    }

Then, to decorate a class, do so like this:

[DebuggerDisplay(DisplayBuilder.DebuggerDisplay)]
    public class MyDataObject {
        public int ID { get; set; }
        public bool Enabled { get; set; }
        public string Message { get; set; }
        public string Other { get; set; }

        protected virtual string GetDebuggerDisplay() {
            return DisplayBuilder.Create()
                .ID(ID)
                .TypeOf(this)
                .Enabled(Enabled) //Only use this if there is an 'Enabled' type of property.
                .Data(Message)
                .Suffix(Other)
                .GetDebuggerDisplay()
                ;
        }
    }

I'd start off by decorating all database classes first.

[hishamco]

@TonyValenti there 're other things important to do for MVP, I suggest to waste your time for something that may not accepted, unless you do it for our personal project, so discussion may useful for such thing

Thanks

[sbwalker]

I would agree with @hishamco - this is not a priority for V2.0

[TonyValenti]

If I were to do the work, would you accept a PR?

[sbwalker]

The point which @hishamco was trying to make above, and the reason I agreed with him, is because Oqtane is a product. Products have infinite ways they can be enhanced. Therefore it is crucial to have a well defined focus - both at the high level in terms of philosophy, as well as at the granular level in terms of the main focus areas for each release - whether those are broader themes or specific features. So the most important ( and also the most uncomfortable ) task for any successful product manager is to be able to say No. And No does not necessarily mean Never. It means, we need to stay focused on the current plan, and we will consider the idea or enhancement for a future iteration. This should all make logical sense to anyone who has been involved in developing products.

However, for whatever reason, people tend to forget this when it comes to open source projects - they think open source projects are just sponges that absorb random bits of new code without any real oversight or management, and somehow magic happens. This is definitely not the case. The most successful open source projects have well defined product management practices in place, and communities which rally around the priorities to produce a predictable and robust outcome. The cool thing about open source, as opposed to proprietary products, is that developers can fork the code and are free to implement their own enhancements. And they can perfect them and test them and then offer them back to the main project for a future release. This freedom and flexibility is one of the fundamentals of open source.