protected override object ImportFromNumber(ImportContext context, JsonReader reader)
 {
     object obj2;
     if (context == null)
     {
         throw new ArgumentNullException("context");
     }
     if (reader == null)
     {
         throw new ArgumentNullException("reader");
     }
     string text = reader.Text;
     try
     {
         obj2 = ImporterBase.ReadReturning(reader, this.ConvertFromString(text));
     }
     catch (FormatException exception)
     {
         throw this.NumberError(exception, text);
     }
     catch (OverflowException exception2)
     {
         throw this.NumberError(exception2, text);
     }
     return obj2;
 }

 protected override object ImportFromObject(ImportContext context, JsonReader reader)
 {
     reader.Read();
     object target = Activator.CreateInstance(base.OutputType);
     INonObjectMemberImporter importer = target as INonObjectMemberImporter;
     while (reader.TokenClass != JsonTokenClass.EndObject)
     {
         string name = reader.ReadMember();
         PropertyDescriptor descriptor = this._properties.Find(name, true);
         if ((descriptor == null) || descriptor.IsReadOnly)
         {
             if ((importer == null) || !importer.Import(context, name, reader))
             {
                 reader.Skip();
             }
         }
         else
         {
             if (this._importers != null)
             {
                 int index = this._properties.IndexOf(descriptor);
                 IObjectMemberImporter importer2 = this._importers[index];
                 if (importer2 != null)
                 {
                     importer2.Import(context, reader, target);
                     continue;
                 }
             }
             descriptor.SetValue(target, context.Import(descriptor.PropertyType, reader));
         }
     }
     return ImporterBase.ReadReturning(reader, target);
 }

 protected override object ImportFromNumber(ImportContext context, JsonReader reader)
 {
     double num;
     object obj2;
     string text = reader.Text;
     try
     {
         num = Convert.ToDouble(text, CultureInfo.InvariantCulture);
     }
     catch (FormatException exception)
     {
         throw NumberError(exception, text);
     }
     catch (OverflowException exception2)
     {
         throw NumberError(exception2, text);
     }
     try
     {
         obj2 = ImporterBase.ReadReturning(reader, UnixTime.ToDateTime(num));
     }
     catch (ArgumentException exception3)
     {
         throw NumberError(exception3, text);
     }
     return obj2;
 }

 protected override object ImportFromString(ImportContext context, JsonReader reader)
 {
     object obj2;
     try
     {
         Match match = Regex.Match(reader.Text, @"\A \/ Date \( ([0-9]+) \) \/ \z", RegexOptions.CultureInvariant | RegexOptions.IgnorePatternWhitespace | RegexOptions.IgnoreCase);
         if (match.Success)
         {
             DateTime time;
             try
             {
                 time = UnixTime.ToDateTime((double) (((double) long.Parse(match.Groups[1].Value, NumberStyles.None, CultureInfo.InvariantCulture)) / 1000.0));
             }
             catch (OverflowException exception)
             {
                 throw StringError(exception);
             }
             return ImporterBase.ReadReturning(reader, time);
         }
         obj2 = ImporterBase.ReadReturning(reader, XmlConvert.ToDateTime(reader.Text, XmlDateTimeSerializationMode.Local));
     }
     catch (FormatException exception2)
     {
         throw StringError(exception2);
     }
     return obj2;
 }

 private object ImportScalarAsArray(ImportContext context, JsonReader reader)
 {
     Type elementType = base.OutputType.GetElementType();
     Array array = Array.CreateInstance(elementType, 1);
     array.SetValue(context.Import(elementType, reader), 0);
     return array;
 }

 protected override object ImportValue(ImportContext context, JsonReader reader)
 {
     if (reader == null)
         throw new ArgumentNullException("reader");
     
     bool value;
     
     if (reader.TokenClass == JsonTokenClass.Number)
     {
         try
         {
             value = Convert.ToInt64(reader.Text, CultureInfo.InvariantCulture) != 0;
         }
         catch (FormatException e)
         {
             throw new JsonException(string.Format("The JSON Number {0} must be an integer to be convertible to System.Boolean.", reader.Text), e);
         }
     }
     else if (reader.TokenClass == JsonTokenClass.Boolean)
     {
         value = reader.Text == JsonBoolean.TrueText;
     }
     else
     {
         throw new JsonException(string.Format("Found {0} where expecting a JSON Boolean.", reader.TokenClass));
     }
     
     return value ? BooleanObject.True : BooleanObject.False;
 }

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

            string text = reader.Text;

            double time;

            try
            {
                time = Convert.ToDouble(text, CultureInfo.InvariantCulture);
            }
            catch (FormatException e)
            {
                throw NumberError(e, text);
            }
            catch (OverflowException e)
            {
                throw NumberError(e, text);
            }

            try
            {
                return ReadReturning(reader, UnixTime.ToDateTime(time));
            }
            catch (ArgumentException e)
            {
                throw NumberError(e, text);
            }
        }

 protected override object ImportFromBoolean(ImportContext context, JsonReader reader)
 {
     Debug.Assert(context != null);
     Debug.Assert(reader != null);
     
     return BooleanObject.Box(reader.ReadBoolean());
 }

		public void Execute()
		{
			this.result.CloseWindow = false;
			this.result.DataChanged = true;

			ImportContext context = new ImportContext(this);

			if (this.EnsureFileLoaded())
			{
				this.actionIndex = 0;
				foreach (var action in this.actions)
				{
					try
					{
						action.DoImport(this.objectSet, context);
					}
					catch (Exception ex)
					{
						this.log.AppendFormat("发生错误:{0} 已终止了操作,堆栈:\r\n{1}\r\n", ex.Message, ex.StackTrace);
						break;
					}

					this.actionIndex++;
				}
			}

			this.log.AppendLine("导入操作结束");
			this.status.CurrentStep = this.status.MaxStep;
			this.status.StatusText = "结束";
			this.status.Response();
			this.result.ProcessLog = this.log.ToString();
		}

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

            if (reader == null)
                throw new ArgumentNullException("reader");
            
            if (reader.TokenClass != JsonTokenClass.Number && reader.TokenClass != JsonTokenClass.String)
                throw new JsonException(string.Format("Found {0} where expecting a number.", reader.TokenClass));

            string text = reader.Text;
            
            try
            {
                return ConvertFromString(text);
            }
            catch (FormatException e)
            {
                throw NumberError(e, text);
            }
            catch (OverflowException e)
            {
                throw NumberError(e, text);
            }
        }

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

            return ReadReturning(reader, reader.Text);
        }

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

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

            //
            // Reader must be sitting on an object.
            //

            if (reader.TokenClass != JsonTokenClass.Object)
                throw new JsonException("Expecting object.");

            reader.Read();

            //
            // Create the NameValueCollection object being deserialized.
            // If a hint was supplied, then that's what we will create
            // here because it could be that the caller wants to
            // return a subtype of NameValueCollection.
            //

            NameValueCollection collection = CreateCollection();

            //
            // Loop through all members of the object.
            //

            while (reader.TokenClass != JsonTokenClass.EndObject)
            {
                string name = reader.ReadMember();

                //
                // If the value is an array, then it's a multi-value
                // entry otherwise a single-value one.
                //

                if (reader.TokenClass == JsonTokenClass.Array)
                {
                    reader.Read();

                    while (reader.TokenClass != JsonTokenClass.EndArray)
                    {
                        collection.Add(name, GetValueAsString(reader));
                        reader.Read();
                    }
                }
                else
                {
                    collection.Add(name, GetValueAsString(reader));
                }

                reader.Read(); // EndArray/String
            }

            return ReadReturning(reader, collection);
        }

 public void CreateObject()
 {
     ObjectSurrogateConstructor ctor = new ObjectSurrogateConstructor(typeof(Surrogate));
     ImportContext context = new ImportContext();
     ObjectConstructionResult result = ctor.CreateObject(context, JsonText.CreateReader("{y:2000,m:12,d:4}"));
     Assert.IsNotNull(result);
     Assert.AreEqual(new DateTime(2000, 12, 4), result.Object);
 }

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

            reader.Read();
            
            object obj = Activator.CreateInstance(OutputType);
            INonObjectMemberImporter otherImporter = obj as INonObjectMemberImporter;
            
            while (reader.TokenClass != JsonTokenClass.EndObject)
            {
                string memberName = reader.ReadMember();
               
                PropertyDescriptor property = _properties.Find(memberName, true);
                
                //
                // Skip over the member value and continue with reading if
                // the property was not found or if the property found cannot
                // be set.
                //
                
                if (property == null || property.IsReadOnly)
                {
                    if (otherImporter == null || !otherImporter.Import(context, memberName, reader))
                        reader.Skip();
                    continue;
                }
                
                //
                // Check if the property defines a custom import scheme.
                // If yes, ask it to import the value into the property 
                // and then continue with the next.
                //
                
                if (_importers != null)
                {
                    int index = _properties.IndexOf(property);
                    
                    IObjectMemberImporter importer = _importers[index];
                    
                    if (importer != null)
                    {
                        importer.Import(context, reader, obj);
                        continue;
                    }
                }
                    
                //
                // Import from reader based on the property type and 
                // then set the value of the property.
                //
                
                property.SetValue(obj, context.Import(property.PropertyType, reader));
            }
         
            return ReadReturning(reader, obj);
        }

 public virtual object Import(ImportContext context, JsonReader reader)
 {
     if (context == null) 
         throw new ArgumentNullException("context");
     if (reader == null) 
         throw new ArgumentNullException("reader");
     
     return JsonBuffer.From(reader);
 }

		protected override void ImportData(System.Xml.XmlNode fieldNode, ImportContext context)
		{
			if (String.IsNullOrEmpty(fieldNode.InnerXml))
			{
				this.SetData(null);
				return;
			}
			this.SetData(ConvertTo(new object[] { fieldNode.InnerXml }));
		}

 private static void AssertImport(object expected, string input)
 {
     JsonTextReader reader = new JsonTextReader(new StringReader(input));
     Type expectedType = expected.GetType();
     ImportContext context = new ImportContext();
     object o = context.Import(expectedType, reader);
     Assert.IsInstanceOfType(expectedType, o);
     Assert.AreEqual(expected, o);
 }

        protected override object ImportFromArray(ImportContext context, JsonReader reader)
        {
            if (_single)
                return _importer(context, reader);

            reader.Read();
            var result = _importer(context, reader);
            reader.ReadToken(JsonTokenClass.EndArray);
            return result;
        }

		protected override void ImportData(System.Xml.XmlNode fieldNode, ImportContext context)
		{
			if (String.IsNullOrEmpty(fieldNode.InnerXml))
			{
				this.SetData(ActiveSchema.DateTimeMinValue);
				return;
			}
			DateTime value = Convert.ToDateTime(fieldNode.InnerXml);
			this.SetData(value < ActiveSchema.DateTimeMinValue ? ActiveSchema.DateTimeMinValue : value);
		}

 protected override object ImportFromArray(ImportContext context, JsonReader reader)
 {
     reader.Read();
     MemoryStream stream = new MemoryStream();
     Type type = typeof(byte);
     while (reader.TokenClass != JsonTokenClass.EndArray)
     {
         stream.WriteByte((byte) context.Import(type, reader));
     }
     return ImporterBase.ReadReturning(reader, stream.ToArray());
 }