public void PrintMessage(IMessageSource sender, ChannelMessage msg)
            {
                if (_verbose == 0)
                {
                    return;
                }
                bool isError = false;

                switch (msg.Kind)
                {
                case ChannelMessageKind.Trace:
                    if (!sender.Verbose)
                    {
                        return;
                    }
                    if (_verbose < 4)
                    {
                        return;
                    }
                    break;

                case ChannelMessageKind.Info:
                    if (_verbose < 2)
                    {
                        return;
                    }
                    break;

                case ChannelMessageKind.Warning:
                    if (_verbose < 2)
                    {
                        return;
                    }
                    isError = true;
                    break;

                default:
                    Contracts.Assert(msg.Kind == ChannelMessageKind.Error);
                    isError = true;
                    break;
                }

                lock (_lock)
                {
                    EnsureNewLine(isError);
                    var wr = isError ? _err : _out;

                    string prefix      = WriteAndReturnLinePrefix(msg.Sensitivity, wr);
                    var    commChannel = sender as PipeBase <ChannelMessage>;
                    if (commChannel?.Verbose == true)
                    {
                        WriteHeader(wr, commChannel);
                    }
                    if (msg.Kind == ChannelMessageKind.Warning)
                    {
                        wr.Write("Warning: ");
                    }
                    _parent.PrintMessageNormalized(wr.AsTextWriter, msg.Message, true, prefix);
                }
            }