C# ImportContext.Register方法代码示例

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

 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 void MemberImportCustomization()
        {
            TestTypeDescriptor logicalType = new TestTypeDescriptor();
            PropertyDescriptorCollection properties = logicalType.GetProperties();

            properties.Add(new TestPropertyDescriptor("prop1", typeof(object), new Hashtable()));

            ArrayList calls2 = new ArrayList();
            TestObjectMemberImporter memberImporter2 = new TestObjectMemberImporter(calls2);
            Hashtable services2 = new Hashtable();
            services2.Add(typeof(IObjectMemberImporter), memberImporter2);
            properties.Add(new TestPropertyDescriptor("prop2", typeof(object), services2));

            // Third property added to exercise issue #27:
            // http://code.google.com/p/jayrock/issues/detail?id=27

            ArrayList calls3 = new ArrayList();
            TestObjectMemberImporter memberImporter3 = new TestObjectMemberImporter(calls3);
            Hashtable services3 = new Hashtable();
            services3.Add(typeof(IObjectMemberImporter), memberImporter3);
            properties.Add(new TestPropertyDescriptor("prop3", typeof(object), services3));

            ComponentImporter importer = new ComponentImporter(typeof(Thing), logicalType);
            ImportContext context = new ImportContext();
            context.Register(importer);
            
            JsonRecorder writer = new JsonRecorder();
            writer.WriteStartObject();
            writer.WriteMember("prop1");
            writer.WriteString("value1");
            writer.WriteMember("prop2");
            writer.WriteString("value2");
            writer.WriteMember("prop3");
            writer.WriteString("value3");
            writer.WriteEndObject();

            JsonReader reader = writer.CreatePlayer();
            Thing thing = (Thing) context.Import(typeof(Thing), reader);

            Assert.AreEqual(1, calls2.Count);

            Assert.AreSame(memberImporter2, calls2[0]);
            Assert.AreEqual(new object[] { context, reader, thing }, memberImporter2.ImportArgs);
            Assert.AreEqual("value2", memberImporter2.ImportedValue);

            Assert.AreEqual(1, calls3.Count);

            Assert.AreSame(memberImporter3, calls3[0]);
            Assert.AreEqual(new object[] { context, reader, thing }, memberImporter3.ImportArgs);
            Assert.AreEqual("value3", memberImporter3.ImportedValue);
        }

        /************************************************************************/
        /* GET                                                                  */
        /************************************************************************/
#if TEST
        public PipelineDescriptor GetPipeline(string pipelineName)
        {
            PipelineDescriptor pipeline = null;
            ImportContext impctx = new ImportContext();
            impctx.Register(new ListImporter<ModuleDescriptor>());
            impctx.Register(new ListImporter<EndpointDescriptor>());
            impctx.Register(new ListImporter<ConnectionDescriptor>());

            switch (pipelineName)
            {
                case "root": 
                    pipeline = (PipelineDescriptor)impctx.Import(
                        typeof(PipelineDescriptor),
                        JsonText.CreateReader(test_RootPipelineJSON));
                    break;

                case "pipeline1":
                    pipeline = (PipelineDescriptor)impctx.Import(
                        typeof(PipelineDescriptor),
                        JsonText.CreateReader(test_Pipeline1JSON));
                    break;
            }

            return pipeline;
        }

        public void MemberImportCustomization()
        {
            ArrayList calls = new ArrayList();

            TestTypeDescriptor logicalType = new TestTypeDescriptor();
            PropertyDescriptorCollection properties = logicalType.GetProperties();

            properties.Add(new TestPropertyDescriptor("prop1", typeof(object), new Hashtable()));

            TestObjectMemberImporter memberImporter = new TestObjectMemberImporter(calls);
            Hashtable services = new Hashtable();
            services.Add(typeof(IObjectMemberImporter), memberImporter);
            properties.Add(new TestPropertyDescriptor("prop2", typeof(object), services));

            ComponentImporter importer = new ComponentImporter(typeof(Thing), logicalType);
            ImportContext context = new ImportContext();
            context.Register(importer);

            JsonRecorder writer = new JsonRecorder();
            writer.WriteStartObject();
            writer.WriteMember("prop1");
            writer.WriteString("value1");
            writer.WriteMember("prop2");
            writer.WriteString("value2");
            writer.WriteEndObject();

            JsonReader reader = writer.CreatePlayer();
            Thing thing = (Thing) context.Import(typeof(Thing), reader);

            Assert.AreEqual(1, calls.Count);

            Assert.AreSame(memberImporter, calls[0]);
            Assert.AreEqual(new object[] { context, reader, thing }, memberImporter.ImportArgs);
            Assert.AreEqual("value2", memberImporter.ImportedValue);
        }

        //! move out of current pipeline
        public PipelineDescriptor NavigatePop()
        {
            ImportContext impctx = new ImportContext();
            impctx.Register(new ListImporter<ModuleDescriptor>());
            impctx.Register(new ListImporter<ConnectionDescriptor>());
            impctx.Register(new ListImporter<EndpointDescriptor>());

            PipelineDescriptor newPipeline = (PipelineDescriptor)impctx.Import(
                typeof(PipelineDescriptor),
                JsonText.CreateReader(test_RootPipelineJSON));

            NuiState.Instance.level--;
            currentPipeline = newPipeline;

            return newPipeline;
        }

        private static void Run()
        {
            ImportContext impctx = new ImportContext();

            //
            // Import a strongly-typed collection of integers...
            //

            impctx.Register(new ListImporter<int>());

            List<int> numbers = (List<int>) impctx.Import(typeof(List<int>), 
                JsonText.CreateReader("[ 1, 2, 3 ]"));
            numbers.ForEach(Console.WriteLine);
            Console.WriteLine();

            //
            // Import a Shape object containing a strongly-typed collection of 
            // Point objects.
            //

            impctx.Register(new ListImporter<Point>());

            Shape shape = (Shape) impctx.Import(typeof(Shape), JsonText.CreateReader(@"{ 
                    name: 'square', 
                    points: [
                        { x: 10, y: 10 },
                        { x: 20, y: 10 }, 
                        { x: 20, y: 20 },
                        { x: 10, y: 20 }
                    ]
                }"));
            JsonConvert.Export(shape, CreatePrettyWriter(Console.Out));
            Console.WriteLine();

            //
            // Import CookieCollection using duck-typing. In other words,
            // as long as CookieCollection walks and quacks like a
            // collection of Cookie elements then it's good enough for
            // DuckCollectionImporter. DuckCollectionImporter can infer
            // that CookieCollection contains Cookie elements.
            //

            impctx.Register(new DuckCollectionImporter(typeof(CookieCollection)));

            const string cookiesText = @"[
                    { name: 'one',   value: 1, expires: '2099-01-02' },
                    { name: 'two',   value: 2, expires: '2088-03-04' },
                    { name: 'three', value: 3, expires: '2077-05-06' }
                ]";
            
            CookieCollection cookies = (CookieCollection) impctx.Import(typeof(CookieCollection), JsonText.CreateReader(cookiesText));
            JsonConvert.Export(cookies, CreatePrettyWriter(Console.Out));
            Console.WriteLine();

            //
            // Now repeat, but replace with a new CookieCollection importer
            // that is identical in behavior but based on generics. Here,
            // the difference is that DuckCollectionImporter<,> does not
            // have to guess the element type as it is provided as a type
            // argument.
            //

            impctx.Register(new DuckCollectionImporter<CookieCollection, Cookie>());
            cookies = (CookieCollection)impctx.Import(typeof(CookieCollection), JsonText.CreateReader(cookiesText));
            JsonConvert.Export(cookies, CreatePrettyWriter(Console.Out));
            Console.WriteLine();

            //
            // Those Cookie objects have a lot of properties. Say our JSON
            // text only needs a subset. Here, we register an exporter that 
            // provides a custom view of the type. We only expose the name, 
            // value and expiration time. What's more, we rename the 
            // Expires property so that it appears as "expiration" in JSON.
            //

            ExportContext expctx = new ExportContext();

            JsonType.
                BuildFor(typeof(Cookie)).
                AddProperty("Name").
                AddProperty("Value").
                AddProperty("Expires").As("expiration").
                Register(expctx);

            expctx.Export(cookies, CreatePrettyWriter(Console.Out));
            Console.WriteLine();
        }

        public void MemberImportCustomization()
        {
            TestObjectMemberImporter memberImporter = new TestObjectMemberImporter();
            Hashtable services = new Hashtable();
            services.Add(typeof(IObjectMemberImporter), memberImporter);

            TestTypeDescriptor logicalType = new TestTypeDescriptor();
            PropertyDescriptorCollection properties = logicalType.GetProperties();
            TestPropertyDescriptor property = new TestPropertyDescriptor("prop", typeof(object), services);
            properties.Add(property);
            
            ComponentImporter importer = new ComponentImporter(typeof(Thing), logicalType);
            ImportContext context = new ImportContext();
            context.Register(importer);
            
            JsonRecorder writer = new JsonRecorder();
            writer.WriteStartObject();
            writer.WriteMember("prop");
            writer.WriteString("value");
            writer.WriteEndObject();

            JsonReader reader = writer.CreatePlayer();
            Thing thing = (Thing) context.Import(typeof(Thing), reader);
            
            Assert.AreSame(context, memberImporter.ImportContext);
            Assert.AreSame(reader, memberImporter.ImportReader);
            Assert.AreSame(thing, memberImporter.ImportTarget);
            Assert.AreEqual("value", memberImporter.ImportedValue);
        }

            public Builder Register(ImportContext context)
            {
                if (context == null) throw new ArgumentNullException("context");

                context.Register(new ComponentImporter(_type, ToCustomType()));
                return this;
            }

        /************************************************************************/
        /* NAVIGATE                                                             */
        /************************************************************************/
        //! move into next pipeline 
#if TEST
        public PipelineDescriptor NavigatePush(int moduleIdx)
        {
            ImportContext impctx = new ImportContext();
            impctx.Register(new ListImporter<ModuleDescriptor>());
            impctx.Register(new ListImporter<ConnectionDescriptor>());
            impctx.Register(new ListImporter<EndpointDescriptor>());

            PipelineDescriptor newPipeline = ((Response<PipelineDescriptor>)impctx.Import(
                typeof(Response<PipelineDescriptor>),
                JsonText.CreateReader(test_Pipeline1JSON))).GetResponse();

            NuiState.Instance.level++;
            currentPipeline = newPipeline;

            return newPipeline;
        }