protected override object ImportFromString(ImportContext context, JsonReader reader)
        {
            Debug.Assert(context != null);
            Debug.Assert(reader != null);

            string s = reader.Text.Trim();

            if (s.Length > 0)
            {
                char ch = s[0];

                if (Char.IsDigit(ch) || ch == '+' || ch == '-')
                    throw Error(s, null);
            }

            try
            {
                return ReadReturning(reader, Enum.Parse(OutputType, s, true));
            }
            catch (ArgumentException e)
            {
                //
                // Value is either an empty string ("") or only contains
                // white space. Value is a name, but not one of the named
                // constants defined for the enumeration.
                //

                throw Error(s, e);
            }
        }

 public void Registration()
 {
     ImportContext context = new ImportContext();
     ThingImporter importer = new ThingImporter();
     context.Register(importer);
     Assert.AreSame(importer, context.FindImporter(typeof(Thing)));
 }

 private static void AssertInStock(Type expected, Type type)
 {
     ImportContext context = new ImportContext();
     IImporter importer = context.FindImporter(type);
     Assert.IsNotNull(importer, "No importer found for {0}", type.FullName);
     Assert.IsInstanceOfType(expected, importer, type.FullName);
 }

        public ObjectConstructionResult CreateObject(ImportContext context, JsonReader reader)
        {
            if (context == null) throw new ArgumentNullException("context");
            if (reader == null) throw new ArgumentNullException("reader");

            return CreateObject(context, JsonBuffer.From(reader).GetMembersArray());
        }

 public void RegistrationIsPerContext()
 {
     ImportContext context = new ImportContext();
     ThingImporter exporter = new ThingImporter();
     context.Register(exporter);
     context = new ImportContext();
     Assert.AreNotSame(exporter, context.FindImporter(typeof(Thing)));
 }

        private TransportComponent()
        {
            JsonExportContext = JsonConvert.CreateExportContext();
              JsonExportContext.Register(new TransportMessageExporter());

              JsonImportContext = JsonConvert.CreateImportContext();
              JsonImportContext.Register(new TransportMessageImporter());

              TransportListeners.Add(this);
        }

 public object Import(ImportContext context, Jayrock.Json.JsonReader reader)
 {
     ActiveReaderMessage arMessage = null;
       Dispatcher.Invoke(DispatcherPriority.Background,
     (Action)delegate()
     {
       arMessage = (ActiveReaderMessage)context.Import<ActiveReaderMessage>(reader); ;
     });
       return arMessage;
 }

        public virtual ObjectConstructionResult CreateObject(ImportContext context, JsonReader reader)
        {
            if (context == null) 
                throw new ArgumentNullException("context");
            if (reader == null) 
                throw new ArgumentNullException("reader");

            IObjectSurrogateConstructor ctor = (IObjectSurrogateConstructor) context.Import(_surrogateType, reader);
            return ctor.CreateObject(context);
        }

        private object ReflectImport(ImportContext context, JsonReader reader)
        {
            if (context == null)
                throw new ArgumentNullException("context");

            if (reader == null)
                throw new ArgumentNullException("reader");

            IJsonImportable o = CreateObject();
            o.Import(context, reader);
            return o;
        }

        public virtual ObjectConstructionResult CreateObject(ImportContext context)
        {
            if (context == null) throw new ArgumentNullException("context");

            JsonBufferWriter tailw = _tailw;
            _tailw = null;
            if (tailw != null)
                tailw.WriteEndObject();
            JsonBuffer tail = (tailw != null ? tailw.GetBuffer() : StockJsonBuffers.EmptyObject);
            object obj = OnCreateObject(context);
            return new ObjectConstructionResult(obj, tail.CreateReader());
        }

        /// <summary>
        /// The import.
        /// </summary>
        /// <param name="context">
        /// The context.
        /// </param>
        /// <param name="reader">
        /// The reader.
        /// </param>
        /// <returns>
        /// The import.
        /// </returns>
        public object Import(ImportContext context, JsonReader reader)
        {
            // var properties = new EvolutionaryProperties();
            // reader.StepOut();
            // JsonToken token = reader.Token;
            this.properties = new EvolutionaryProperties();

            PropertyValue[] o = context.Import<PropertyValue[]>(reader);
            this.SetProperties(o);

            return this.properties;
        }

        protected override object ImportFromArray(ImportContext context, JsonReader reader)
        {
            Debug.Assert(context != null);
            Debug.Assert(reader != null);

            reader.Read();

            ArrayList list = new ArrayList();
            Type elementType = OutputType.GetElementType();

            while (reader.TokenClass != JsonTokenClass.EndArray)
                list.Add(context.Import(elementType, reader));

            return ReadReturning(reader, list.ToArray(elementType));
        }

        public virtual bool Import(ImportContext context, string name, JsonReader reader)
        {
            if (context == null) throw new ArgumentNullException("context");
            if (reader == null) throw new ArgumentNullException("reader");

            JsonBufferWriter tailw = _tailw;
            if (tailw == null)
            {
                tailw = _tailw = new JsonBufferWriter();
                tailw.WriteStartObject();
            }
            tailw.WriteMember(name);
            tailw.WriteFromReader(reader);
            return true;
        }

        protected override void ImportElements(object collection, ImportContext context, JsonReader reader)
        {
            if (collection == null) throw new ArgumentNullException("collection");
            if (context == null) throw new ArgumentNullException("context");
            if (reader == null) throw new ArgumentNullException("reader");

            object[] args = null;
            while (reader.TokenClass != JsonTokenClass.EndArray)
            {
                if (args == null)           // on-demand
                    args = new object[1];

                args[0] = context.Import(ElementType, reader);
                InvokeAdd(collection, args);
            }
        }

        protected override object ImportFromArray(ImportContext context, JsonReader reader)
        {
            if (context == null) throw new ArgumentNullException("context");
            if (reader == null) throw new ArgumentNullException("reader");

            object collection = CreateCollection();

            reader.ReadToken(JsonTokenClass.Array);

            ImportElements(collection, context, reader);

            if (reader.TokenClass != JsonTokenClass.EndArray)
                throw new Exception("Implementation error.");

            reader.Read();
            return collection;
        }

        public JsonRpcDispatchScope(JsonRpcDispatcher dispatcher, HttpContext context) 
        {
            Debug.Assert(dispatcher != null);
            Debug.Assert(context != null);

            //
            // Setup for local execution if client request is from the same
            // machine. The dispatcher uses this to determine whether to 
            // emit a detailed stack trace or not in the event of an error.
            //

            if (HttpRequestSecurity.IsLocal(context.Request))
                dispatcher.LocalExecution = true;

            //
            // Initialize the import and export contexts, which are pooled
            // per-application instance.
            //

            IDictionary appVars = AppVars.Get(context.ApplicationInstance);

            ExportContext expctx = (ExportContext) appVars[typeof(ExportContext)];

            if (expctx == null)
            {
                expctx = JsonConvert.CreateExportContext();
                appVars.Add(typeof(ExportContext), expctx);
            }
            
            dispatcher.JsonExporter = new JsonExportHandler(expctx.Export);

            ImportContext impctx = (ImportContext) appVars[typeof(ImportContext)];

            if (impctx == null)
            {
                impctx = JsonConvert.CreateImportContext();
                appVars.Add(typeof(ImportContext), impctx);
            }

            dispatcher.JsonImporter = new JsonImportHandler(impctx.Import);

            _impctx = impctx;
            _expctx = expctx;
        }

 public virtual object Import(ImportContext context, JsonReader reader)
 {
     if (context == null)
         throw new ArgumentNullException("context");
     
     if (reader == null)
         throw new ArgumentNullException("reader");
     
     if (!reader.MoveToContent())
         throw new JsonException("Unexpected EOF.");
     
     if (reader.TokenClass == JsonTokenClass.Null)
     {
         return ImportNull(context, reader);
     }
     else if (reader.TokenClass == JsonTokenClass.String)
     {
         return ImportFromString(context, reader);
     }
     else if (reader.TokenClass == JsonTokenClass.Number)
     {
         return ImportFromNumber(context, reader);
     }
     else if (reader.TokenClass == JsonTokenClass.Boolean)
     {
         return ImportFromBoolean(context, reader);
     }
     else if (reader.TokenClass == JsonTokenClass.Array)
     {
         return ImportFromArray(context, reader);
     }
     else if (reader.TokenClass == JsonTokenClass.Object)
     {
         return ImportFromObject(context, reader);
     }
     else 
     {
         throw new JsonException(string.Format("{0} not expected.", reader.TokenClass));
     }
 }

 public void NonMemberImport()
 {
     ComponentImporter importer = new ComponentImporter(typeof(DynamicThing));
     ImportContext context = new ImportContext();
     const string json = "{ str1: value1, str2: value2, num: 42 }";
     DynamicThing thing = (DynamicThing) importer.Import(context, JsonText.CreateReader(json));
     Assert.AreEqual(2, thing.NonMembers.Count);
     Assert.AreEqual("value1", thing.NonMembers["str1"]);
     Assert.AreEqual("value2", thing.NonMembers["str2"]);
 }

 protected override object ImportFromString(ImportContext context, JsonReader reader)
 {
     return ReflectImport(context, reader);
 }

 public bool Import(ImportContext context, string name, JsonReader reader)
 {
     if (reader.TokenClass != JsonTokenClass.String)
         return false;
     NonMembers[name] = context.Import(reader);
     return true;
 }