public HelloResponse Any(Hello request)
        {
            String response = esbProxy.Invoke("ESB_COM_WS", "HelloAction", "Hello From ServiceStack!");


            return new HelloResponse { Result = "Hello, {0}!".Fmt(request.Name) };
        }

        public void Test_Hello_No_Features_Set()
        {
            var features = new List<short>();

            var hello = new Hello("couchbase-net-sdk/2.1.4", features.ToArray(), Transcoder, 0, 0);
            var result = IOService.Execute(hello);
            Assert.IsTrue(result.Success);
        }

        public void Test_KeySeqnoObserver()
        {

            var configuration = new ClientConfiguration
            {
                Servers = new List<Uri>
                {
                    new Uri(ConfigurationManager.AppSettings["bootstrapUrl"])
                }
            };

            var key = "Test_KeySeqnoObserver";
            using (var cluster = new Cluster(configuration))
            {
                using (var bucket = cluster.OpenBucket())
                {
                    bucket.Remove(key);
                }
            }

            configuration.Initialize();

            var provider = new CarrierPublicationProvider(
                configuration,
                (pool) => new PooledIOService(pool),
                (config, endpoint) => new ConnectionPool<Connection>(config, endpoint),
                SaslFactory.GetFactory(),
                new DefaultConverter(),
                new DefaultTranscoder(new DefaultConverter(), new DefaultSerializer()));

            var configInfo = provider.GetConfig("default");

            var features = new List<short>();
            features.Add((short)ServerFeatures.MutationSeqno);

            var keyMapper = configInfo.GetKeyMapper();
            var mappedNode = keyMapper.MapKey(key);
            var node = mappedNode.LocatePrimary();

            foreach (var server in configInfo.Servers.Where(x=>x.IsDataNode))
            {
                var hello = new Hello("couchbase-net-sdk/2.1.4", features.ToArray(), provider.Transcoder, 0, 0);
                var result3 = server.Send(hello);
                Assert.IsTrue(result3.Success);
            }

            var result = node.Send(new Add<string>(key, "", (VBucket)mappedNode,
                new DefaultTranscoder(new DefaultConverter(), new DefaultSerializer()), 1000));

            var clusterController = new Mock<IClusterController>();
            clusterController.Setup(x => x.Transcoder).Returns(new DefaultTranscoder());

            var pending = new ConcurrentDictionary<uint, IOperation>();

            var keyObserver = new KeySeqnoObserver("thekey", pending, configInfo, clusterController.Object, 0, 1000);
            var durabilityReached = keyObserver.Observe(result.Token, ReplicateTo.Zero, PersistTo.One);
            Assert.IsTrue(durabilityReached);
        }

        public object Any(Hello request)
        {
            if (string.IsNullOrEmpty(request.Name))
            {
                throw new ArgumentNullException("Name");
            }

            return new HelloResponse { Result = "Hello " + request.Name };
        }

 public static void Main()
 {
     Hello h = new Hello("stranger");
     GoodBye g = new GoodBye("my friend");
     Farewell f = new Farewell("you fool");
     h.speak();
     g.speak();
     f.speak();
 }

 public object Any(Hello request)
 {
     return new HelloResponse
     {
         Result = "Hello, {0}{1}!".Fmt(
             request.Title != null ? request.Title + ". " : "",
             request.Name)
     };
 }

        public void Test_Hello_With_Features_MutationSeqno_And_TcpNodelay_Set()
        {
            var features = new List<short>();
            features.Add((short)ServerFeatures.MutationSeqno);
            features.Add((short)ServerFeatures.TcpNoDelay);

            var hello = new Hello("couchbase-net-sdk/2.1.4", features.ToArray(), Transcoder, 0, 0);
            var result = IOService.Execute(hello);
            Assert.IsTrue(result.Success);
        }

        public void ExecuteTest()
        {
            // Initialise Instance
            var target = new Hello { Message = "World" };

            // Invoke the Workflow
            var actual = WorkflowInvoker.Invoke(target);

            // Test the result
            Assert.AreEqual("Hello World", actual);
        }

 public static void Encode(IByteWriter stream, Hello encodedHello) {
   Uint32.Encode(stream, encodedHello.LedgerVersion);
   Uint32.Encode(stream, encodedHello.OverlayVersion);
   Uint32.Encode(stream, encodedHello.OverlayMinVersion);
   Hash.Encode(stream, encodedHello.NetworkID);
   XdrEncoding.WriteString(stream, encodedHello.VersionStr);
   XdrEncoding.EncodeInt32(encodedHello.ListeningPort, stream);
   NodeID.Encode(stream, encodedHello.PeerID);
   AuthCert.Encode(stream, encodedHello.Cert);
   Uint256.Encode(stream, encodedHello.Nonce);
 }

        public object Any(Hello request)
        {
            var response = new HelloResponse { Result = "Hello, " + request.Name };

            if (Request.Files.Length > 0)
            {
                response.Result += ".\nFiles: {0}, name: {1}, size: {2} bytes".Fmt(Request.Files.Length, Request.Files[0].FileName, Request.Files[0].ContentLength);
            }

            return response;
        }

 static void Main()
 {
     Foo foo = new Bar (81);
     Hello hello = new Hello (0x12345678);
     object obj = foo;
     object boxed = hello;
     ValueType value = hello;
     Console.WriteLine (foo);
     Console.WriteLine (obj);
     Console.WriteLine (boxed);
     Console.WriteLine (value);
 }

        public object Any(Hello request)
        {
            //Issue 1 
            
            //This now fails. 
            var campaign = new Campaign();
            campaign.TrackingId = 0;
            campaign.CampaignPhone = "none";
            campaign.CostAmount = 0M;
            campaign.EndDate = 0L;
            campaign.StartDate = SystemClock.Instance.Now.Ticks / NodaConstants.TicksPerMillisecond;
            campaign.FixedCost = 0M;
            campaign.IsActive = true;
            campaign.IsRetread = true;
            campaign.IsFactorTrustApp = true;
            campaign.IsFactorTrustLeads = true;
            campaign.IsDuplicate = true;
            campaign.IsEmail = true;
            campaign.MasterId = 0;
            campaign.IsFirmOffer = false;
            campaign.LeadDelCostTypeId = 0;
            campaign.LeadDelRespTypeId = 0;
            campaign.LeadDelTypeId = 0;
            campaign.LeadRoutingTypeId = 0;
            campaign.Name = "Exception Campaign";
            campaign.IsExceptionCampaign = true;
            campaign.IsDefaultCampaign = false;
            campaign.IsActive = true;

            var rowId = Db.Insert(campaign, true);
            


            //Issue 2


            // This is also broken

/*            var campaigns = Db.Dictionary<int, string>(Db.
                    From<Campaign>().
                    Select(x => new { x.Id, x.Name }).
                    Where(x => x.IsActive));*/

            // but yet, this works

            /*var campaigns = Db.Dictionary<int, string>("select id, name from campaign where isactive = 1");*/




            return new HelloResponse { Result = "Hello, {0}!".Fmt(request.Name) };
        }

 public static Hello Decode(IByteReader stream) {
   Hello decodedHello = new Hello();
   decodedHello.LedgerVersion = Uint32.Decode(stream);
   decodedHello.OverlayVersion = Uint32.Decode(stream);
   decodedHello.OverlayMinVersion = Uint32.Decode(stream);
   decodedHello.NetworkID = Hash.Decode(stream);
   decodedHello.VersionStr = XdrEncoding.ReadString(stream);
   decodedHello.ListeningPort = XdrEncoding.DecodeInt32(stream);
   decodedHello.PeerID = NodeID.Decode(stream);
   decodedHello.Cert = AuthCert.Decode(stream);
   decodedHello.Nonce = Uint256.Decode(stream);
   return decodedHello;
 }

        static void Main(string[] args)
        {
            ChannelServices.RegisterChannel(new TcpClientChannel());
            ChannelServices.RegisterChannel(new HttpClientChannel());

            RemotingConfiguration.RegisterWellKnownClientType(
                typeof(Wrox.ProfessionalCSharp.Hello),
                "tcp://localhost:8086/Hi");

            /*			Hello obj = (Hello)Activator.GetObject(
                typeof(Wrox.ProfessionalCSharp.Hello),
                "tcp://localhost:8086/Hi");
            */

            Hello obj = new Hello();
            //	Hello obj = (Hello)RemotingServices.Connect(typeof(Wrox.ProfessionalCSharp.Hello),
            //		"http://localhost:8085/Hi");

            if (obj == null)
            {
                Console.WriteLine("could not locate server");
                return;
            }

            MySerialized ser = obj.GetMySerialized();
            if (!RemotingServices.IsTransparentProxy(ser))
            {
                Console.WriteLine("ser is not a transparent proxy");
            }
            ser.Foo();

            MyRemote rem = obj.GetMyRemote();
            if (RemotingServices.IsTransparentProxy(rem))
            {
                Console.WriteLine("rem is a transparent proxy");
            }
            rem.Foo();
            /*
            MySerialized ser1 = new MySerialized(1);
            obj.InSerialized(ser1);
            Console.WriteLine(ser1.A);

            MySerialized ser2 = new MySerialized(2);
            obj.RefSerialized(ref ser2);
            Console.WriteLine(ser2.A);

            MySerialized ser3;
            obj.OutSerialized(out ser3);
            Console.WriteLine(ser3.A);
            */
        }

    public void TestHello()
    {
        var hello = new Hello();
        hello.PrintHello("Hello world");

        Assert.That(hello.add(1, 1), Is.EqualTo(2));
        Assert.That(hello.add(5, 5), Is.EqualTo(10));

        Assert.IsTrue(hello.test1(3, 3.0f));
        Assert.IsFalse(hello.test1(2, 3.0f));

        var foo = new Foo { A = 4, B = 7 };
        Assert.That(hello.AddFoo(foo), Is.EqualTo(11));
        Assert.That(hello.AddFooPtr(foo), Is.EqualTo(11));
        Assert.That(hello.AddFooPtr(foo), Is.EqualTo(11));
        Assert.That(hello.AddFooRef(foo), Is.EqualTo(11));
        unsafe
        {
            var pointer = foo.SomePointer;
            var pointerPointer = foo.SomePointerPointer;
            for (int i = 0; i < 4; i++)
            {
                Assert.AreEqual(i, pointer[i]);
                Assert.AreEqual(i, (*pointerPointer)[i]);
            }
        }

        var bar = new Bar { A = 4, B = 7 };
        Assert.That(hello.AddBar(bar), Is.EqualTo(11));
        Assert.That(bar.RetItem1(), Is.EqualTo(Bar.Item.Item1));

        var retFoo = hello.RetFoo(7, 2.0f);
        Assert.That(retFoo.A, Is.EqualTo(7));
        Assert.That(retFoo.B, Is.EqualTo(2.0));

        var foo2 = new Foo2 { A = 4, B = 2, C = 3 };
        Assert.That(hello.AddFoo(foo2), Is.EqualTo(6));
        Assert.That(hello.AddFoo2(foo2), Is.EqualTo(9));

        var bar2 = new Bar2 { A = 4, B = 7, C = 3 };
        Assert.That(hello.AddBar2(bar2), Is.EqualTo(14));

        Assert.That(hello.RetEnum(Enum.A), Is.EqualTo(0));
        Assert.That(hello.RetEnum(Enum.B), Is.EqualTo(2));
        Assert.That(hello.RetEnum(Enum.C), Is.EqualTo(5));
        //Assert.That(hello.RetEnum(Enum.D), Is.EqualTo(-2147483648));
        Assert.That(hello.RetEnum(Enum.E), Is.EqualTo(1));
        Assert.That(hello.RetEnum(Enum.F), Is.EqualTo(-9));
    }

    public void TestPrimitiveConstCharStringInOut()
    {
        var hello = new Hello();

        string str;
        hello.StringOut(out str);
        Assert.That(str, Is.EqualTo("HelloStringOut"));
        hello.StringOutRef(out str);
        Assert.That(str, Is.EqualTo("HelloStringOutRef"));
        str = "Hello";
        hello.StringInOut(ref str);
        Assert.That(str, Is.EqualTo("StringInOut"));
        str = "Hello";
        hello.StringInOutRef(ref str);
        Assert.That(str, Is.EqualTo("StringInOutRef"));
    }

    static int Main()
    {
        AppDomain domain = AppDomain.CreateDomain ("Test"); // @MDB LINE: main
        Assembly ass = Assembly.GetExecutingAssembly ();
        Hello hello = (Hello) domain.CreateInstanceAndUnwrap (ass.FullName, "Hello");
        Console.WriteLine ("TEST: {0}", hello);
        hello.World ();

        Hello bar = new Hello ();
        bar.World ();

        hello.World ();			// @MDB BREAKPOINT: main2
        bar.World ();

        AppDomain.Unload (domain);	// @MDB BREAKPOINT: unload
        return 0;
    }

        public void Test_Hello_With_Feature_MutationSeqno_Set()
        {
            var features = new List<short>();
            features.Add((short)ServerFeatures.MutationSeqno);

            var hello = new Hello("couchbase-net-sdk/2.1.4", features.ToArray(), Transcoder, 0, 0);
            var result = IOService.Execute(hello);
            Assert.IsTrue(result.Success);
            var key = "bar";

            var delete = new Delete(key, GetVBucket(), Transcoder, OperationLifespanTimeout);
            var deleteResult = IOService.Execute(delete);

            var add = new Add<string>(key, "foo", GetVBucket(), Transcoder, OperationLifespanTimeout);
            var result2 =IOService.Execute(add);
            Assert.IsNotNull(result2.Token);
        }

        public void ExecuteTest2()
        {
            // Initialise Instance
            var target = new Hello { Message = "World" };

            // Declare additional parameters
            var parameters = new Dictionary<string, object>
            {
                { "Message2", " hope you are well" },
            };

            // Create the Workflow object
            WorkflowInvoker invoker = new WorkflowInvoker(target);

            // Create a Mock build detail object
            IBuildDetail t = new MockIBuildDetail { BuildNumber = "MyBuildNumber" };
            invoker.Extensions.Add(t);

            // Invoke the workflow
            var actual = invoker.Invoke(parameters);

            // Test the result wich is now accessed via the named Result key
            Assert.AreEqual("Hello World hope you are well from MyBuildNumber", actual["Result"]);
        }

 public object Any(Hello request)
 {
     return new HelloResponse { Result = "Hello, {0}!".Fmt(request.Name) };
 }