mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/Hosting/ImportEngineTests.cs

   1 // -----------------------------------------------------------------------\r
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.\r
   3 // -----------------------------------------------------------------------\r
   4 using System;\r
   5 using System.UnitTesting;\r
   6 using System.ComponentModel.Composition;\r
   7 using System.ComponentModel.Composition.Factories;\r
   8 using System.ComponentModel.Composition.Hosting;\r
   9 using Microsoft.VisualStudio.TestTools.UnitTesting;\r
  10 using System.ComponentModel.Composition.Primitives;\r
  11 \r
  12 namespace System.ComponentModel.Composition\r
  13 {\r
  14     [TestClass]\r
  15     public class ImportEngineTests\r
  16     {\r
  17         [TestMethod]\r
  18         public void PreviewImports_Successful_NoAtomicComposition_ShouldBlockChanges()\r
  19         {\r
  20             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
  21             var engine = new ImportEngine(exportProvider);\r
  22 \r
  23             var import = ImportDefinitionFactory.Create("Value");\r
  24             var importer = PartFactory.CreateImporter(import);\r
  25 \r
  26             exportProvider.AddExport("Value", 21);\r
  27 \r
  28             engine.PreviewImports(importer, null);\r
  29 \r
  30             ExceptionAssert.Throws<ChangeRejectedException>(() =>\r
  31                 exportProvider.AddExport("Value", 22));\r
  32 \r
  33             ExceptionAssert.Throws<ChangeRejectedException>(() =>\r
  34                 exportProvider.RemoveExport("Value"));\r
  35 \r
  36             GC.KeepAlive(importer);\r
  37         }\r
  38 \r
  39         [TestMethod]\r
  40         public void PreviewImports_Unsuccessful_NoAtomicComposition_ShouldNotBlockChanges()\r
  41         {\r
  42             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
  43             var engine = new ImportEngine(exportProvider);\r
  44 \r
  45             var import = ImportDefinitionFactory.Create("Value");\r
  46             var importer = PartFactory.CreateImporter(import);\r
  47 \r
  48             ExceptionAssert.Throws<CompositionException>(() =>\r
  49                 engine.PreviewImports(importer, null));\r
  50 \r
  51             exportProvider.AddExport("Value", 22);\r
  52             exportProvider.AddExport("Value", 23);\r
  53             exportProvider.RemoveExport("Value");\r
  54 \r
  55             GC.KeepAlive(importer);\r
  56         }\r
  57 \r
  58         [TestMethod]\r
  59         public void PreviewImports_Successful_AtomicComposition_Completeted_ShouldBlockChanges()\r
  60         {\r
  61             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
  62             var engine = new ImportEngine(exportProvider);\r
  63 \r
  64             var import = ImportDefinitionFactory.Create("Value");\r
  65             var importer = PartFactory.CreateImporter(import);\r
  66 \r
  67             exportProvider.AddExport("Value", 21);\r
  68 \r
  69             using (var atomicComposition = new AtomicComposition())\r
  70             {\r
  71                 engine.PreviewImports(importer, atomicComposition);\r
  72                 atomicComposition.Complete();\r
  73             }\r
  74 \r
  75             ExceptionAssert.Throws<ChangeRejectedException>(() =>\r
  76                 exportProvider.AddExport("Value", 22));\r
  77 \r
  78             ExceptionAssert.Throws<ChangeRejectedException>(() =>\r
  79                 exportProvider.RemoveExport("Value"));\r
  80 \r
  81             GC.KeepAlive(importer);\r
  82         }\r
  83 \r
  84         [TestMethod]\r
  85         public void PreviewImports_Successful_AtomicComposition_RolledBack_ShouldNotBlockChanges()\r
  86         {\r
  87             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
  88             var engine = new ImportEngine(exportProvider);\r
  89 \r
  90             var import = ImportDefinitionFactory.Create("Value");\r
  91             var importer = PartFactory.CreateImporter(import);\r
  92 \r
  93             exportProvider.AddExport("Value", 21);\r
  94 \r
  95             using (var atomicComposition = new AtomicComposition())\r
  96             {\r
  97                 engine.PreviewImports(importer, atomicComposition);\r
  98 \r
  99                 // Let atomicComposition get disposed thus rolledback\r
 100             }\r
 101 \r
 102             exportProvider.AddExport("Value", 22);\r
 103             exportProvider.RemoveExport("Value");\r
 104 \r
 105             GC.KeepAlive(importer);\r
 106         }\r
 107 \r
 108         [TestMethod]\r
 109         public void PreviewImports_Unsuccessful_AtomicComposition_ShouldNotBlockChanges()\r
 110         {\r
 111             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 112             var engine = new ImportEngine(exportProvider);\r
 113 \r
 114             var import = ImportDefinitionFactory.Create("Value");\r
 115             var importer = PartFactory.CreateImporter(import);\r
 116 \r
 117             using (var atomicComposition = new AtomicComposition())\r
 118             {\r
 119                 ExceptionAssert.Throws<ChangeRejectedException>(() =>\r
 120                     engine.PreviewImports(importer, atomicComposition));\r
 121             }\r
 122 \r
 123             exportProvider.AddExport("Value", 22);\r
 124             exportProvider.AddExport("Value", 23);\r
 125             exportProvider.RemoveExport("Value");\r
 126 \r
 127             GC.KeepAlive(importer);\r
 128         }\r
 129 \r
 130         [TestMethod]\r
 131         public void PreviewImports_ReleaseImports_ShouldNotBlockChanges()\r
 132         {\r
 133             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 134             var engine = new ImportEngine(exportProvider);\r
 135 \r
 136             var import = ImportDefinitionFactory.Create("Value");\r
 137             var importer = PartFactory.CreateImporter(import);\r
 138 \r
 139             exportProvider.AddExport("Value", 21);\r
 140 \r
 141             engine.PreviewImports(importer, null);\r
 142 \r
 143             ExceptionAssert.Throws<ChangeRejectedException>(() =>\r
 144                 exportProvider.AddExport("Value", 22));\r
 145 \r
 146             ExceptionAssert.Throws<ChangeRejectedException>(() =>\r
 147                 exportProvider.RemoveExport("Value"));\r
 148 \r
 149             engine.ReleaseImports(importer, null);\r
 150 \r
 151             exportProvider.AddExport("Value", 22);\r
 152             exportProvider.RemoveExport("Value");\r
 153 \r
 154             GC.KeepAlive(importer);\r
 155         }\r
 156 \r
 157         [TestMethod]\r
 158         public void PreviewImports_MissingOptionalImport_ShouldSucceed()\r
 159         {\r
 160             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 161             var engine = new ImportEngine(exportProvider);\r
 162 \r
 163             var import = ImportDefinitionFactory.Create("Value", ImportCardinality.ZeroOrOne);\r
 164             var importer = PartFactory.CreateImporter(import);\r
 165 \r
 166             engine.PreviewImports(importer, null);\r
 167 \r
 168             GC.KeepAlive(importer);\r
 169         }\r
 170 \r
 171         [TestMethod]\r
 172         public void PreviewImports_ZeroCollectionImport_ShouldSucceed()\r
 173         {\r
 174             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 175             var engine = new ImportEngine(exportProvider);\r
 176 \r
 177             var import = ImportDefinitionFactory.Create("Value", ImportCardinality.ZeroOrMore);\r
 178             var importer = PartFactory.CreateImporter(import);\r
 179 \r
 180             engine.PreviewImports(importer, null);\r
 181 \r
 182             GC.KeepAlive(importer);\r
 183         }\r
 184 \r
 185         [TestMethod]\r
 186         public void PreviewImports_MissingOptionalImport_NonRecomposable_ShouldNotBlockChanges()\r
 187         {\r
 188             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 189             var engine = new ImportEngine(exportProvider);\r
 190 \r
 191             var import = ImportDefinitionFactory.Create("Value", ImportCardinality.ZeroOrOne, false, false);\r
 192             var importer = PartFactory.CreateImporter(import);\r
 193 \r
 194             engine.PreviewImports(importer, null);\r
 195 \r
 196             exportProvider.AddExport("Value", 21);\r
 197             exportProvider.AddExport("Value", 22);\r
 198             exportProvider.RemoveExport("Value");\r
 199 \r
 200             GC.KeepAlive(importer);\r
 201         }\r
 202 \r
 203         [TestMethod]\r
 204         public void PreviewImports_ZeroCollectionImport_NonRecomposable_ShouldNotBlockChanges()\r
 205         {\r
 206             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 207             var engine = new ImportEngine(exportProvider);\r
 208 \r
 209             var import = ImportDefinitionFactory.Create("Value", ImportCardinality.ZeroOrMore, false, false);\r
 210             var importer = PartFactory.CreateImporter(import);\r
 211 \r
 212             engine.PreviewImports(importer, null);\r
 213 \r
 214             exportProvider.AddExport("Value", 21);\r
 215             exportProvider.AddExport("Value", 22);\r
 216             exportProvider.RemoveExport("Value");\r
 217 \r
 218             GC.KeepAlive(importer);\r
 219         }\r
 220 \r
 221         [TestMethod]\r
 222         public void SatisfyImports_NonRecomposable_ValueShouldNotChange()\r
 223         {\r
 224             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 225             var engine = new ImportEngine(exportProvider);\r
 226 \r
 227             exportProvider.AddExport("Value", 21);\r
 228 \r
 229             var import = ImportDefinitionFactory.Create("Value", false);\r
 230             var importer = PartFactory.CreateImporter(import);\r
 231 \r
 232             engine.SatisfyImports(importer);\r
 233 \r
 234             Assert.AreEqual(21, importer.GetImport(import));\r
 235 \r
 236             // After rejection batch failures throw ChangeRejectedException to indicate that\r
 237             // the failure did not affect the container\r
 238             ExceptionAssert.Throws<ChangeRejectedException>(() =>\r
 239                 exportProvider.ReplaceExportValue("Value", 42));\r
 240 \r
 241             Assert.AreEqual(21, importer.GetImport(import), "Value should not change!");\r
 242 \r
 243             GC.KeepAlive(importer);\r
 244         }\r
 245 \r
 246         [TestMethod]\r
 247         public void SatisfyImports_Recomposable_ValueShouldChange()\r
 248         {\r
 249             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 250             var engine = new ImportEngine(exportProvider);\r
 251 \r
 252             exportProvider.AddExport("Value", 21);\r
 253 \r
 254             var import = ImportDefinitionFactory.Create("Value", true);\r
 255             var importer = PartFactory.CreateImporter(import);\r
 256 \r
 257             engine.SatisfyImports(importer);\r
 258 \r
 259             Assert.AreEqual(21, importer.GetImport(import));\r
 260 \r
 261             exportProvider.ReplaceExportValue("Value", 42);\r
 262 \r
 263             Assert.AreEqual(42, importer.GetImport(import), "Value should change!");\r
 264 \r
 265             GC.KeepAlive(importer);\r
 266         }\r
 267 \r
 268         [TestMethod]\r
 269         public void SatisfyImports_NonRecomposable_Prerequisite_ValueShouldNotChange()\r
 270         {\r
 271             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 272             var engine = new ImportEngine(exportProvider);\r
 273 \r
 274             var import = ImportDefinitionFactory.Create("Value", false, true);\r
 275             var importer = PartFactory.CreateImporter(import);\r
 276 \r
 277             exportProvider.AddExport("Value", 21);\r
 278 \r
 279             engine.SatisfyImports(importer);\r
 280 \r
 281             Assert.AreEqual(21, importer.GetImport(import));\r
 282 \r
 283             ExceptionAssert.Throws<ChangeRejectedException>(() =>\r
 284                 exportProvider.ReplaceExportValue("Value", 42));\r
 285 \r
 286             Assert.AreEqual(21, importer.GetImport(import), "Value should NOT change!");\r
 287 \r
 288             GC.KeepAlive(importer);\r
 289         }\r
 290 \r
 291         [TestMethod]\r
 292         public void SatisfyImports_Recomposable_Prerequisite_ValueShouldChange()\r
 293         {\r
 294             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 295             var engine = new ImportEngine(exportProvider);\r
 296 \r
 297             var import = ImportDefinitionFactory.Create("Value", true, true);\r
 298             var importer = PartFactory.CreateImporter(import);\r
 299 \r
 300             exportProvider.AddExport("Value", 21);\r
 301 \r
 302             engine.SatisfyImports(importer);\r
 303 \r
 304             Assert.AreEqual(21, importer.GetImport(import));\r
 305 \r
 306             exportProvider.ReplaceExportValue("Value", 42);\r
 307 \r
 308             Assert.AreEqual(42, importer.GetImport(import), "Value should change!");\r
 309 \r
 310             GC.KeepAlive(importer);\r
 311         }\r
 312 \r
 313         [TestMethod]\r
 314         public void SatisfyImports_OneRecomposable_OneNotRecomposable()\r
 315         {\r
 316             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 317             var engine = new ImportEngine(exportProvider);\r
 318 \r
 319             var import1 = ImportDefinitionFactory.Create("Value", true);\r
 320             var import2 = ImportDefinitionFactory.Create("Value", false);\r
 321             var importer = PartFactory.CreateImporter(import1, import2);\r
 322 \r
 323             exportProvider.AddExport("Value", 21);\r
 324 \r
 325             engine.SatisfyImports(importer);\r
 326 \r
 327             // Initial compose values should be 21\r
 328             Assert.AreEqual(21, importer.GetImport(import1));\r
 329             Assert.AreEqual(21, importer.GetImport(import2));\r
 330 \r
 331             // Reset value to ensure it doesn't get set to same value again\r
 332             importer.ResetImport(import1);\r
 333             importer.ResetImport(import2);\r
 334 \r
 335             ExceptionAssert.Throws<ChangeRejectedException>(() =>\r
 336                 exportProvider.ReplaceExportValue("Value", 42));\r
 337 \r
 338             Assert.AreEqual(null, importer.GetImport(import1), "Value should NOT have been set!");\r
 339             Assert.AreEqual(null, importer.GetImport(import2), "Value should NOT have been set!");\r
 340 \r
 341             GC.KeepAlive(importer);\r
 342         }\r
 343 \r
 344         [TestMethod]\r
 345         public void SatisfyImports_TwoRecomposables_SingleExportValueChanged()\r
 346         {\r
 347             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 348             var engine = new ImportEngine(exportProvider);\r
 349 \r
 350             var import1 = ImportDefinitionFactory.Create("Value1", true);\r
 351             var import2 = ImportDefinitionFactory.Create("Value2", true);\r
 352             var importer = PartFactory.CreateImporter(import1, import2);\r
 353 \r
 354             exportProvider.AddExport("Value1", 21);\r
 355             exportProvider.AddExport("Value2", 23);\r
 356 \r
 357             engine.SatisfyImports(importer);\r
 358 \r
 359             Assert.AreEqual(21, importer.GetImport(import1));\r
 360             Assert.AreEqual(23, importer.GetImport(import2));\r
 361 \r
 362             importer.ResetImport(import1);\r
 363             importer.ResetImport(import2);\r
 364 \r
 365             // Only change Value1 \r
 366             exportProvider.ReplaceExportValue("Value1", 42);\r
 367 \r
 368             Assert.AreEqual(42, importer.GetImport(import1), "Value should have been set!");\r
 369 \r
 370             Assert.AreEqual(null, importer.GetImport(import2), "Value should NOT have changed to the value in the container.");\r
 371 \r
 372             GC.KeepAlive(importer);\r
 373         }\r
 374 \r
 375         [TestMethod]\r
 376         public void SatisfyImports_Recomposable_Unregister_ValueShouldChangeOnce()\r
 377         {\r
 378             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 379             var engine = new ImportEngine(exportProvider);\r
 380 \r
 381             exportProvider.AddExport("Value", 21);\r
 382 \r
 383             var import = ImportDefinitionFactory.Create("Value", true);\r
 384             var importer = PartFactory.CreateImporter(import);\r
 385 \r
 386             engine.SatisfyImports(importer);\r
 387 \r
 388             Assert.AreEqual(21, importer.GetImport(import));\r
 389 \r
 390             exportProvider.ReplaceExportValue("Value", 42);\r
 391 \r
 392             Assert.AreEqual(42, importer.GetImport(import), "Value should change!");\r
 393 \r
 394             engine.ReleaseImports(importer, null);\r
 395 \r
 396             exportProvider.ReplaceExportValue("Value", 666);\r
 397 \r
 398             Assert.AreEqual(42, importer.GetImport(import), "Value should not change!");\r
 399 \r
 400             GC.KeepAlive(importer);\r
 401         }\r
 402 \r
 403         [TestMethod]\r
 404         public void SatisfyImports_MissingOptionalImport_NonRecomposable_ShouldNotBlockChanges()\r
 405         {\r
 406             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 407             var engine = new ImportEngine(exportProvider);\r
 408 \r
 409             var import = ImportDefinitionFactory.Create("Value", ImportCardinality.ZeroOrOne, false, false);\r
 410             var importer = PartFactory.CreateImporter(import);\r
 411 \r
 412             exportProvider.AddExport("Value", 20);\r
 413 \r
 414             engine.SatisfyImports(importer);\r
 415 \r
 416             ExceptionAssert.Throws<ChangeRejectedException>(() =>\r
 417                 exportProvider.AddExport("Value", 21));\r
 418 \r
 419             ExceptionAssert.Throws<ChangeRejectedException>(() =>\r
 420                 exportProvider.RemoveExport("Value"));\r
 421 \r
 422             GC.KeepAlive(importer);\r
 423         }\r
 424 \r
 425         [TestMethod]\r
 426         public void SatisfyImports_ZeroCollectionImport_NonRecomposable_ShouldNotBlockChanges()\r
 427         {\r
 428             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 429             var engine = new ImportEngine(exportProvider);\r
 430 \r
 431             var import = ImportDefinitionFactory.Create("Value", ImportCardinality.ZeroOrMore, false, false);\r
 432             var importer = PartFactory.CreateImporter(import);\r
 433 \r
 434             exportProvider.AddExport("Value", 20);\r
 435 \r
 436             engine.SatisfyImports(importer);\r
 437 \r
 438             ExceptionAssert.Throws<ChangeRejectedException>(() =>\r
 439                 exportProvider.AddExport("Value", 21));\r
 440 \r
 441             ExceptionAssert.Throws<ChangeRejectedException>(() =>\r
 442                 exportProvider.RemoveExport("Value"));\r
 443 \r
 444             GC.KeepAlive(importer);\r
 445         }\r
 446 \r
 447         [TestMethod]\r
 448         public void SatisfyImports_MissingOptionalImport_Recomposable_ShouldNotBlockChanges()\r
 449         {\r
 450             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 451             var engine = new ImportEngine(exportProvider);\r
 452 \r
 453             var import = ImportDefinitionFactory.Create("Value", ImportCardinality.ZeroOrOne, true, false);\r
 454             var importer = PartFactory.CreateImporter(import);\r
 455 \r
 456             exportProvider.AddExport("Value", 20);\r
 457 \r
 458             engine.SatisfyImports(importer);\r
 459 \r
 460             exportProvider.AddExport("Value", 21);\r
 461             exportProvider.RemoveExport("Value");\r
 462 \r
 463             GC.KeepAlive(importer);\r
 464         }\r
 465 \r
 466         [TestMethod]\r
 467         public void SatisfyImports_ZeroCollectionImport_Recomposable_ShouldNotBlockChanges()\r
 468         {\r
 469             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 470             var engine = new ImportEngine(exportProvider);\r
 471 \r
 472             var import = ImportDefinitionFactory.Create("Value", ImportCardinality.ZeroOrMore, true, false);\r
 473             var importer = PartFactory.CreateImporter(import);\r
 474 \r
 475             exportProvider.AddExport("Value", 20);\r
 476 \r
 477             engine.SatisfyImports(importer);\r
 478 \r
 479             exportProvider.AddExport("Value", 21);\r
 480             exportProvider.RemoveExport("Value");\r
 481 \r
 482             GC.KeepAlive(importer);\r
 483         }\r
 484 \r
 485         [TestMethod]\r
 486         public void SatisfyImportsOnce_Recomposable_ValueShouldNotChange_NoRecompositionRequested()\r
 487         {\r
 488             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 489             var engine = new ImportEngine(exportProvider);\r
 490 \r
 491             exportProvider.AddExport("Value", 21);\r
 492 \r
 493             var import = ImportDefinitionFactory.Create("Value", true);\r
 494             var importer = PartFactory.CreateImporter(import);\r
 495 \r
 496             engine.SatisfyImportsOnce(importer);\r
 497 \r
 498             Assert.AreEqual(21, importer.GetImport(import));\r
 499 \r
 500             exportProvider.ReplaceExportValue("Value", 42);\r
 501 \r
 502             Assert.AreEqual(21, importer.GetImport(import), "Value should not change!");\r
 503 \r
 504             GC.KeepAlive(importer);\r
 505         }\r
 506 \r
 507         [TestMethod]\r
 508         public void SatisifyImportsOnce_Recomposable_ValueShouldNotChange_NoRecompositionRequested_ViaNonArgumentSignature()\r
 509         {\r
 510             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 511             var engine = new ImportEngine(exportProvider);\r
 512 \r
 513             exportProvider.AddExport("Value", 21);\r
 514 \r
 515             var import = ImportDefinitionFactory.Create("Value", true);\r
 516             var importer = PartFactory.CreateImporter(import);\r
 517 \r
 518             engine.SatisfyImportsOnce(importer);\r
 519 \r
 520             Assert.AreEqual(21, importer.GetImport(import));\r
 521 \r
 522             exportProvider.ReplaceExportValue("Value", 42);\r
 523 \r
 524             Assert.AreEqual(21, importer.GetImport(import), "Value should not change!");\r
 525 \r
 526             GC.KeepAlive(importer);\r
 527         }\r
 528 \r
 529         [TestMethod]\r
 530         public void SatisfyImportsOnce_Successful_ShouldNotBlockChanges()\r
 531         {\r
 532             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 533             var engine = new ImportEngine(exportProvider);\r
 534 \r
 535             var import = ImportDefinitionFactory.Create("Value");\r
 536             var importer = PartFactory.CreateImporter(import);\r
 537 \r
 538             exportProvider.AddExport("Value", 21);\r
 539 \r
 540             engine.SatisfyImportsOnce(importer);\r
 541 \r
 542             exportProvider.AddExport("Value", 22);\r
 543             exportProvider.RemoveExport("Value");\r
 544 \r
 545             GC.KeepAlive(importer);\r
 546         }\r
 547 \r
 548         [TestMethod]\r
 549         public void SatisfyImportsOnce_Unsuccessful_ShouldNotBlockChanges()\r
 550         {\r
 551             var exportProvider = ExportProviderFactory.CreateRecomposable();\r
 552             var engine = new ImportEngine(exportProvider);\r
 553 \r
 554             var import = ImportDefinitionFactory.Create("Value");\r
 555             var importer = PartFactory.CreateImporter(import);\r
 556 \r
 557             ExceptionAssert.Throws<CompositionException>(() =>\r
 558                 engine.SatisfyImportsOnce(importer));\r
 559 \r
 560             exportProvider.AddExport("Value", 22);\r
 561             exportProvider.AddExport("Value", 23);\r
 562             exportProvider.RemoveExport("Value");\r
 563 \r
 564             GC.KeepAlive(importer);\r
 565         }\r
 566     }\r
 567 }