C#

1)
to see what goes wrong, look at the intermediate results, so print at least p.text.Lenght,
and if necessary (but this may get very large) p.text itself, or part of it, e.g.
p.text.Substring(0,80)
You may want to create a function that does this in an intelligent way, i.e.
printing length, and full or partial contentdepending on size.

2)
regular expressions use special characters such as \ and | and some more.
to get them literally, you should escape them so to get a | you need a \|
But then the C/C++/C# languages will try to interpret the backslash, so you must
either escape it again (hence \\|) or prefix the entire constant string by a @ sign
(@"...\|...")

3)
I dont think there is a need to use 0x7C when what you want is a vertical bar;
just type | and you will get more readable code.

4)
general advice: if something goes wrong, break it down into smaller pieces, until]
you can easily see where it starts to go wrong. In this particular case:
print intermediate values, reduce the size of the problem (fewer than 20 strings!);
if this does not help, perform some experiments (e.g. on the behaviour of Regex).

Greetings,

:cool:

PaulC1972 wrote:

You can obfuscate it.

S. Senthil Kumar wrote:

as a single static reference in a base class would mean that all derived classes will share that single instance.

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

namespace Test
{
    public interface IRenderer
    {
        void Render();
    }

    public abstract class Renderer : IRenderer
    {
        static IRenderer renderer;

        protected Renderer(){}

        public abstract void Render();

        public static IRenderer Instance
        {
            get
            {
                if (renderer == null)
                {
                    renderer = RendererFactory.CreateRenderer();
                }
                return renderer;
            }
        }
    }

    class RendererFactory
    {
        internal static IRenderer CreateRenderer()
        {
            return new ThreeDRenderer();
        }
    }

    public class ThreeDRenderer : Renderer
    {
        protected ThreeDRenderer(){}
        public override void Render() { Console.WriteLine("3DRenderer" + this.GetHashCode()); }
    }

    public class TwoDRenderer : Renderer
    {
        protected TwoDRenderer(){}
        public override void Render() { Console.WriteLine("2DRenderer" + this.GetHashCode()); }
    }

    public class ConsoleMain
    {
        public static void Main(string[] args)
        {
            Renderer.Instance.Render();
            Renderer.Instance.Render();
        }
    }
}

S. Senthil Kumar wrote:

Does this help?

public abstract void Render();

ScruffyDuck wrote:

I have been playing around using bit shifting but it is not working.

ScruffyDuck wrote:

wonder if they are little endian so the bit sequence is turned around by pairs.