C# ContainerBuilder.UseDatenMeisterDotNet方法代码示例

        public void TestWithMetaClass()
        {
            var kernel = new ContainerBuilder();
            var builder = kernel.UseDatenMeisterDotNet(new IntegrationSettings { PathToXmiFiles = "Xmi" });
            using (var scope = builder.BeginLifetimeScope())
            {
                var dataLayerLogic = scope.Resolve<IDataLayerLogic>();
                var dataLayers = scope.Resolve<DataLayers>();
                var umlDataLayer = dataLayers.Uml;
                var uml = dataLayerLogic.Get<_UML>(umlDataLayer);
                Assert.That(uml, Is.Not.Null);

                var extent = new XmlUriExtent("dm:///test");
                extent.Workspaces = scope.Resolve<IWorkspaceCollection>();
                dataLayerLogic.AssignToDataLayer(extent, dataLayers.Types);

                var factory = scope.Resolve<IFactoryMapper>().FindFactoryFor(scope, extent);

                var interfaceClass = uml.SimpleClassifiers.__Interface;
                var element = factory.create(interfaceClass);
                Assert.That(element, Is.Not.Null);

                extent.elements().add(element);
                Assert.That(extent.elements().size(), Is.EqualTo(1));

                var retrievedElement = extent.elements().ElementAt(0) as IElement;
                Assert.That(retrievedElement, Is.Not.Null);
                Assert.That(retrievedElement.getMetaClass(), Is.Not.Null);
                Assert.That(retrievedElement.metaclass, Is.Not.Null);
                var foundMetaClass = retrievedElement.metaclass;
                Assert.That(foundMetaClass.Equals(interfaceClass), Is.True);
            }
        }

        public void TestGeneralizedProperties()
        {
            var kernel = new ContainerBuilder();
            kernel.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource());
            var builder = kernel.UseDatenMeisterDotNet(new IntegrationSettings { PathToXmiFiles = "Xmi" });
            using (var scope = builder.BeginLifetimeScope())
            {
                var classifierMethods = scope.Resolve<ClassifierMethods>();
                classifierMethods.Legacy = false;
                var dataLayers = scope.Resolve<DataLayers>();
                var dataLayerLogic = scope.Resolve<DataLayerLogic>();

                // Gets the logic
                var uml = dataLayerLogic.Get<_UML>(dataLayers.Uml);
                var feature = uml.Classification.__Feature;
                var properties = classifierMethods.GetPropertiesOfClassifier(feature).ToList();

                Assert.That(properties.Contains(_UML._Classification._Feature.isStatic), Is.True,
                    "isStatic");
                Assert.That(properties.Contains(_UML._Classification._RedefinableElement.isLeaf), Is.True,
                    "isLeaf (Parent)");
                Assert.That(properties.Contains(_UML._CommonStructure._NamedElement.name), Is.True,
                    "name (Parent of Parent)");
            }
        }

        public void TestFactoryMappingByAttributeForExtentLoaders()
        {
            var kernel = new ContainerBuilder();
            var builder = kernel.UseDatenMeisterDotNet(new IntegrationSettings {PathToXmiFiles = "Xmi"});
            using (var scope = builder.BeginLifetimeScope())
            {

                var mapper = new ManualConfigurationToExtentStorageMapper();
                mapper.PerformMappingForConfigurationOfExtentLoaders();

                Assert.That(mapper.HasMappingFor(typeof(CSVStorageConfiguration)), Is.True);
                Assert.That(mapper.HasMappingFor(typeof(CSVDataProvider)), Is.False);
            }
        }

        public void TestCreatabeTypes()
        {
            var kernel = new ContainerBuilder();
            var builder = kernel.UseDatenMeisterDotNet(new IntegrationSettings {PathToXmiFiles = "Xmi"});
            using (var scope = builder.BeginLifetimeScope())
            {
                // Apply for zipcodes
                var integrateZipCodes = scope.Resolve<Integrate>();
                integrateZipCodes.Into(scope.Resolve<IWorkspaceCollection>().FindExtent("dm:///types"));

                var extentFunctions = scope.Resolve<ExtentFunctions>();
                var dataLayers = scope.Resolve<DataLayers>();

                var dataExtent = new MofUriExtent("dm:///test");
                var creatableTypes = extentFunctions.GetCreatableTypes(dataExtent);
                Assert.That(creatableTypes, Is.Not.Null);
                Assert.That(creatableTypes.MetaLayer, Is.EqualTo(dataLayers.Types));
                Assert.That(creatableTypes.CreatableTypes.Count, Is.EqualTo(1));
            }
        }

        public void TestXmlExtentStorage()
        {
            var kernel = new ContainerBuilder();

            var builder = kernel.UseDatenMeisterDotNet(new IntegrationSettings { PathToXmiFiles = "Xmi" });
            using (var scope = builder.BeginLifetimeScope())
            {
                var path = Path.Combine(
                    Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
                    $"testing{new Random().Next(0, 100000)}.xml");
                if (File.Exists(path))
                {
                    File.Delete(path);
                }

                var storageConfiguration = new XmiStorageConfiguration
                {
                    ExtentUri = "dm:///test",
                    Path = path,
                    Workspace = "Data"
                };

                // Creates the extent
                var loader = scope.Resolve<IExtentStorageLoader>();
                var loadedExtent = loader.LoadExtent(storageConfiguration, true);
                Assert.That(loadedExtent, Is.TypeOf<XmlUriExtent>());

                // Includes some data
                var factory = scope.Resolve<IFactoryMapper>().FindFactoryFor(scope, loadedExtent);
                var createdElement = factory.create(null);
                Assert.That(createdElement, Is.TypeOf<XmlElement>());
                loadedExtent.elements().add(createdElement);

                createdElement.set("test", "Test");
                Assert.That(createdElement.get("test"), Is.EqualTo("Test"));

                // Stores the extent
                loader.StoreExtent(loadedExtent);

                // Detaches it
                loader.DetachExtent(loadedExtent);

                // Reloads it
                storageConfiguration.ExtentUri = "dm:///test_new";

                var newExtent = loader.LoadExtent(storageConfiguration, false);
                Assert.That(newExtent.elements().size(), Is.EqualTo(1));
                Assert.That((newExtent.elements().ElementAt(0) as IElement).get("test"), Is.EqualTo("Test"));
            }
        }

        private IContainer CreateKernel(IAppBuilder app)
        {
            var settings = new IntegrationSettings
            {
                PathToXmiFiles = "App_Data/Xmi",
                EstablishDataEnvironment = true
            };

            var kernel = new ContainerBuilder();
            var container = kernel.UseDatenMeisterDotNet(settings);

            // Defines the shutdown
            var properties = new AppProperties(app.Properties);
            var token = properties.OnAppDisposing;
            token.Register(() =>
            {
                _lifetimeScope.UnuseDatenMeister();
            });

            return container;
        }