コード例 #1
0
        public async Task <ActionResult> UpdateIndex(long id)
        {
            var service = new CustomerService();
            var types   = new TypesService();
            var model   = new CustomerModel();

            var result = await service.ReadCustomerByIdOrName(id);

            if (result.Code == 200)
            {
                var documentTypes = await types.GetDocumentTypes();

                var countries = await types.GetCountries();

                var departments = await types.GetDepartments(result.Data.CountryId);

                var cities = await types.GetCities(result.Data.DepartmentId, result.Data.CountryId);

                model = result.Data;
                model.DocumentTypes = documentTypes.Data;
                model.Countries     = countries.Data;
                model.Departments   = departments.Data;
                model.Cities        = cities.Data;
            }

            return(View(model));
        }
コード例 #2
0
ファイル: Program.cs プロジェクト: lanicon/XmlToCode
        // Generate an enum class from a MetaData.xml
        static void Main(string[] args)
        {
            // Get input data
            Console.WriteLine("### input data");
            IList <VehicleTypeDto> vehicleTypes = new TypesService()
                                                  .GetVehicleTypes();

            vehicleTypes.ForEach(x => Console.WriteLine(x));
            Console.WriteLine();

            // Generate enumeration class
            Console.WriteLine("### generate class");
            string className = "VehicleType";
            string code      = new CodeGenerator(Assembly.GetEntryAssembly().GetName().Name)
                               .CreateClass(className, vehicleTypes);

            Console.WriteLine(code);

            Console.WriteLine("### add file to project");
            new ProjectAppender().
            AddFile(className, code);

            Console.WriteLine("### output new class");
            // Output contains not the latest generated file! Project needs to be reloaded!
            // todo: Doesn't work if code is generated with errors or the file doesn't exist
            VehicleType.GetAll().ToList().ForEach(x => Console.WriteLine(x));

            Console.ReadLine();
        }
コード例 #3
0
        public async Task <ActionResult> GetCities(long countryId, long departmentId)
        {
            var service = new TypesService();
            var deps    = await service.GetCities(departmentId, countryId);

            return(Json(deps, JsonRequestBehavior.AllowGet));
        }
コード例 #4
0
        public void SetUp()
        {
            _typesRepo = new Mock<ITypesRepository>();
            _typesService = new TypesService(_typesRepo.Object);
           

        }
コード例 #5
0
ファイル: TypeServiceTest.cs プロジェクト: kazo0/Dexr
        public void WhenGettingAllTypes_ShouldReturnEighteenType()
        {
            var allTypes = new TypesService(null).GetAllTypes().ToList();

            allTypes.ShouldNotContain(PokemonType.Unknown);
            allTypes.Count().ShouldBe(18);
        }
コード例 #6
0
 /// <summary>
 /// use this method only when recreate a map or the map id the database is null
 /// </summary>
 /// <param name="MapName"></param>
 /// <param name="layers"></param>
 /// <param name="racks"></param>
 /// <param name="columns"></param>
 /// <returns></returns>
 public Entity.Map CreateNewMap(string MapName, int layers, int racks, int columns)
 {
     using (TransactionScope scope = new TransactionScope())
     {
         Map             = new Entity.Map();
         Map.MapName     = MapName;
         Map.RackCount   = racks;
         Map.LayerCount  = layers;
         Map.ColumnCount = columns;
         //first save map initial messages
         this.MapDictionaryService = new Repository.MapDictionaryService();
         this.MapDictionaryService.InsertMap(Map);
         //Reset Zones' static color
         Zone.ResetRrandomColor();
         //initial all services as the map reference for one
         InitialServices(Map);
         //create general types list
         List <Entity.Types> generalTypes = TypesService.LoadTypes();
         if (generalTypes.Count == 0)//if there has no types in the database, create new and save from code
         {
             generalTypes = GetGeneralTypes();
             this.TypesService.InsertTypes(generalTypes);
         }
         //ALERT!! must be constrainted here as the same name of all the GENERAL_TYPES, or will has logical error
         //ALERT!! you can modify and make contraint from "public class ItemTypesString" in this singleton class
         Entity.Types tt = Map.Types.Single(t => t.Name == ItemTypesString.ITEM_TYPE_DEFAULT_STORAGE);
         this._default_storage = tt;
         //then set mapitems, default type Id is zt's Type Id
         List <Entity.MapItems> additionMapItemList = new List <MapItems>();
         for (int i = 0; i < layers; i++)
         {
             for (int j = 0; j < racks; j++)
             {
                 for (int k = 0; k < columns; k++)
                 {
                     Entity.MapItems tmp     = new Entity.MapItems();
                     DAL.MapItems    DAL_tmp = new DAL.MapItems()
                     {
                         MapItemLayer  = i,
                         MapItemRack   = j,
                         MapItemColumn = k,
                         TypeId        = tt.Id,
                         ZoneId        = 0,
                         CargowayId    = 0,
                         Status        = (int)MapItems.MapItemStatus.STATUS_NOT_STORAGE
                     };
                     tmp.DAL_SetMapItem(DAL_tmp);
                     additionMapItemList.Add(tmp);
                 }
             }
         }
         MapItemsService.InsertMapItems(additionMapItemList);
         scope.Complete();
     }
     return(Map);
 }
コード例 #7
0
        /// <summary>
        /// Creates new instance of Workspace type
        /// </summary>
        internal Workspace(Guid snapshotId, TimeSpan timeout, INodeProvider <Guid, object, EdgeData> nodeProvider, IWorkspaceFacade commitTarget, ProxyCreatorService proxyCreatorService, TypesService typesService, IsolationLevel isolationLevel, IProxyMap immutableProxyMap)
        {
            this.workspaceId = Guid.NewGuid();
            this.thread      = Thread.CurrentThread;

            if (!typeof(TDataType).IsInterface)
            {
                throw new ArgumentException("Interface type expected: " + typeof(TDataType).AssemblyQualifiedName);
            }

            this.snapshotId          = snapshotId;
            this.nodeProvider        = nodeProvider;
            this.proxyCreatorService = proxyCreatorService;
            this.typesService        = typesService;
            this.isolationLevel      = isolationLevel;
            this.workspaceFacade     = commitTarget;
            this.immutableProxyMap   = immutableProxyMap;

            workspaceFacade.OpenWorkspace(workspaceId, snapshotId, isolationLevel, timeout);

            if (isolationLevel == IsolationLevel.ReadOnly)
            {
                // Rely directly on parent provider if read only
                this.objectInstancesService     = new ObjectInstancesService(nodeProvider, typesService);
                this.immutableInstancesService  = new ObjectInstancesService(nodeProvider, typesService);
                this.collectionInstancesService = new CollectionInstancesService(nodeProvider, typesService);
                this.dictionaryInstancesService = new DictionaryInstancesService(nodeProvider, typesService);
            }
            else
            {
                // Construct isolated provider for local changes
                var isolatedStorage = new DirectNodeProviderUnsafe <Guid, object, EdgeData>(new MemoryStorageUnsafe <Guid, object>(), false);
                isolatedProvider                = new IsolatedNodeProvider(nodeProvider, isolatedStorage, thread);
                this.objectInstancesService     = new ObjectInstancesService(isolatedProvider, typesService);
                this.immutableInstancesService  = new ObjectInstancesService(nodeProvider, typesService);
                this.collectionInstancesService = new CollectionInstancesService(isolatedProvider, typesService);
                this.dictionaryInstancesService = new DictionaryInstancesService(isolatedProvider, typesService);
            }

            this.runtimeProxyFacade = new RuntimeProxyFacade(typesService, objectInstancesService, immutableInstancesService, collectionInstancesService, new CollectionInstancesService(nodeProvider, typesService), dictionaryInstancesService, new DictionaryInstancesService(nodeProvider, typesService), mutableProxyMap, immutableProxyMap, proxyCreatorService);

            // Initialize root data proxy
            var rootObjectId = commitTarget.GetRootObjectId(snapshotId);

            rootProxy = proxyCreatorService.NewObject <TDataType>(runtimeProxyFacade, rootObjectId, isolationLevel == IsolationLevel.ReadOnly);

            if (isolationLevel == IsolationLevel.ReadOnly)
            {
                immutableProxyMap.AddProxy(rootObjectId, rootProxy);
            }
            else
            {
                mutableProxyMap.AddProxy(rootObjectId, rootProxy);
            }
        }
コード例 #8
0
 public RuntimeProxyFacade(TypesService typesService, ObjectInstancesService objectInstancesService, ObjectInstancesService immutableInstancesService, CollectionInstancesService collectionInstancesService, CollectionInstancesService immutableCollectionInstancesService, DictionaryInstancesService dictionaryInstancesService, DictionaryInstancesService immutableDictionaryInstancesService, IProxyMap mutableProxyMap, IProxyMap immutableProxyMap, ProxyCreatorService proxyCreatorService)
 {
     this.objectInstancesService              = objectInstancesService;
     this.immutableInstancesService           = immutableInstancesService;
     this.collectionInstancesService          = collectionInstancesService;
     this.dictionaryInstancesService          = dictionaryInstancesService;
     this.immutableCollectionInstancesService = immutableCollectionInstancesService;
     this.immutableDictionaryInstancesService = immutableDictionaryInstancesService;
     this.mutableProxyMap     = mutableProxyMap;
     this.immutableProxyMap   = immutableProxyMap;
     this.proxyCreatorService = proxyCreatorService;
     this.typesService        = typesService;
 }
コード例 #9
0
        /// <summary>
        /// Initializes the ProxyFacade class
        /// </summary>
        /// <param name="typesService">Service for type manipulation</param>
        public static void Initialize(TypesService typesService)
        {
            if (typesService == null)
            {
                throw new ArgumentNullException("typesService");
            }

            StaticProxyFacade inst = new StaticProxyFacade();

            inst.typesService = typesService;

            instance = inst; // Instance initialized
        }
コード例 #10
0
        public TypeViewModel(Type type, TypesService typesService)
        {
            DeferValidationUntilFirstSaveCall = false;

            _modelBackup           = type.CreateBackup();
            _typesService          = typesService;
            Type                   = type;
            RedirectTargets        = _typesService.GetRedirectTargets(type);
            TypesRedirectingToThis = (from t in Type.GlobalTypes
                                      where t.RedirectType == type
                                      orderby t.FullTypeName
                                      select t).ToList();
            AllowRedirect = TypesRedirectingToThis.Count == 0;
        }
コード例 #11
0
        public async Task <ActionResult> CreateIndex()
        {
            var service = new TypesService();
            var model   = new CustomerModel();

            var documentsTypes = await service.GetDocumentTypes();

            var countries = await service.GetCountries();

            model.DocumentTypes = documentsTypes.Data;
            model.Countries     = countries.Data;

            return(View(model));
        }
コード例 #12
0
        public async Task <ActionResult> DeleteIndex(long id)
        {
            var service = new CustomerService();
            var types   = new TypesService();
            var model   = new CustomerModel();

            var result = await service.ReadCustomerByIdOrName(id);

            if (result.Code == 200)
            {
                model = result.Data;
            }

            return(View(model));
        }
コード例 #13
0
        public TypesCharacteristicsViewModel(DataPersisterService dataPersisterService, GlobalService globalService,
                                             IUIVisualizerService visualizerService, IViewModelFactory viewModelFactory,
                                             CharacteristicsService characteristicsService, TypesService typesService,
                                             IAdvancedMessageService advancedMessageService)
        {
            _dataPersisterService   = dataPersisterService;
            _visualizerService      = visualizerService;
            _viewModelFactory       = viewModelFactory;
            _globalService          = globalService;
            _characteristicsService = characteristicsService;
            _typesService           = typesService;
            _advancedMessageService = advancedMessageService;

            Title = "Edit Types / Characteristics";

            AddTypeCommand       = new TaskCommand(OnAddTypeCommandExecuteAsync);
            EditTypeCommand      = new TaskCommand(OnEditTypeCommandExecuteAsync, EditTypeCanExecute);
            DeleteTypeCommand    = new TaskCommand(OnDeleteTypeCommandExecuteAsync, DeleteTypeCanExecute);
            ShowTypeUsageCommand = new TaskCommand(OnShowTypeUsageCommandExecuteAsync, ShowTypeUsageCanExecute);

            AddCharacteristicCommand  = new TaskCommand(OnAddCharacteristicCommandExecuteAsync);
            EditCharacteristicCommand =
                new TaskCommand(OnEditCharacteristicCommandExecuteAsync, EditCharacteristicCanExecute);
            DeleteCharacteristicCommand =
                new TaskCommand(OnDeleteCharacteristicCommandExecuteAsync, DeleteCharacteristicCanExecute);
            ShowCharacteristicUsageCommand = new TaskCommand(OnShowCharacteristicUsageCommandExecuteAsync,
                                                             ShowCharacteristicUsageCanExecute);

            SelectedTypes.CollectionChanged           += SelectedTypesOnCollectionChanged;
            SelectedCharacteristics.CollectionChanged += SelectedCharacteristicsOnCollectionChanged;

            Types           = _typesService.TypeUsages;
            Characteristics = _characteristicsService.CharacteristicUsages;

            _characteristicsService.UpdateCharacteristicsUsages();
            _typesService.UpdateTypesUsages();

            TypesView = (ListCollectionView)CollectionViewSource.GetDefaultView(_typesService.TypeUsages);
            TypesView.IsLiveSorting   = false;
            TypesView.IsLiveFiltering = false;

            CharacteristicsView =
                (ListCollectionView)CollectionViewSource.GetDefaultView(
                    _characteristicsService.CharacteristicUsages);
            CharacteristicsView.IsLiveSorting   = false;
            CharacteristicsView.IsLiveFiltering = false;
        }
コード例 #14
0
ファイル: ClientContext.cs プロジェクト: nemanjazz/iog
        private void InitializeServices()
        {
            typesService = new TypesService(provider);

            var interfaceToTypeIdMapping = typesService.InitializeTypeSystem(serverContext.EntityTypes);

            var completeTypesList = interfaceToTypeIdMapping.Keys;

            generationService = new GenerationService(typesService);
            // TODO (nsabo) Optional loading of proxy types from the given assembly (we dont want always to generate on small devices, Silverlight...)
            // Note: Collection/Dictionary types are not saved in the assembly
            var interfaceToGeneratedMapping = generationService.GenerateProxyTypes(completeTypesList, Properties.Settings.Default.SaveGeneratedAssemblyToDisk, Properties.Settings.Default.GeneratedAssemblyFileName);

            proxyCreatorService = new ProxyCreatorService(completeTypesList, interfaceToTypeIdMapping, interfaceToGeneratedMapping);

            StaticProxyFacade.Initialize(typesService);
        }
コード例 #15
0
ファイル: TypeServiceTest.cs プロジェクト: kazo0/Dexr
        public void GivenADoubleWeakPokemon_MultiplierShouldBeCorrect(
            PokemonType moveType,
            PokemonType defendingPokemonType1,
            PokemonType defendingPokemonType2,
            float expectedMultiplier)
        {
            var defendingPokemon = new Pokemon()
            {
                Types = new[] { defendingPokemonType1, defendingPokemonType2 }
            };
            var attackingMove = new QuickMove()
            {
                Type = moveType
            };

            var effectivenessSource = CreateEffectivenessSource();
            var typeService         = new TypesService(effectivenessSource);

            typeService.GetTypeAdvantageMultiplier(attackingMove, defendingPokemon).Result.ShouldBe(expectedMultiplier);
        }
コード例 #16
0
        private async void LoadTypes()
        {
            var result = await TypesService.GetAll();

            result.ForEach(x => Types.Add(x));
        }
コード例 #17
0
        private void InitializeServices(Type rootEntityType, Type[] entityTypes, UpgradeConfiguration upgradeConfiguration)
        {
            this.rootEntityType = rootEntityType;
            this.entityTypes    = entityTypes;

            typesService = new TypesService(provider);

            objectSerializationService.TypesService = typesService;

            var interfaceToTypeIdMapping = typesService.InitializeTypeSystem(entityTypes);

            var completeTypesList = interfaceToTypeIdMapping.Keys;

            generationService = new GenerationService(typesService);
            // TODO (nsabo) Optional loading of proxy types from the given assembly (we dont want always to generate on small devices, Silverlight...)
            // Note: Collection/Dictionary types are not saved in the assembly
            var interfaceToGeneratedMapping = generationService.GenerateProxyTypes(completeTypesList, Properties.Settings.Default.SaveGeneratedAssemblyToDisk, Properties.Settings.Default.GeneratedAssemblyFileName);

            proxyCreatorService = new ProxyCreatorService(completeTypesList, interfaceToTypeIdMapping, interfaceToGeneratedMapping);

            snapshotsService = new SnapshotsService(provider);

            #region Parent map provider setup
            if (Properties.Settings.Default.ParentMappingFileStorageUsed)
            {
                // Usage of file for caching parent information
                var indexedFile = new IndexedFileStorage(new FileStream(this.parentMappingFileName, FileMode.Create), Properties.Settings.Default.ParentMappingFileBlockSize, false);
                indexedFile.Serializer = this.objectSerializationService;
                disposables.Add(indexedFile);

                var parentProviderStorage = new CachedWriteNodeProviderUnsafe <Guid, object, EdgeData>(
                    new DirectNodeProviderUnsafe <Guid, object, EdgeData>(indexedFile, true),
                    new LimitedDirectNodeProviderUnsafe <Guid, object, EdgeData>(
                        new LimitedMemoryStorageUnsafe <Guid, object>(Properties.Settings.Default.ParentMappingMemoryMinimumCount, Properties.Settings.Default.ParentMappingMemoryMaximumCount), false)
                    );
                disposables.Add(parentProviderStorage);

                mutableParentProvider = new ParentMapProvider(parentProviderStorage, provider, null, true);
            }
            else
            {
                // Default parent information is stored in memory and has only the last snapshot available
                mutableParentProvider = new ParentMapProvider(new DirectNodeProviderUnsafe <Guid, object, EdgeData>(new MemoryStorageUnsafe <Guid, object>(), false), provider, null, true);
            }
            #endregion

            #region Merge rule provider setup
            IMergeRuleProvider mergeRuleProvider = null;

            if (SnapshotIsolationEnabled)
            {
                if (Properties.Settings.Default.ConcurrencyAutoOverrideResolution)
                {
                    mergeRuleProvider = new AutoOverrideMergeRuleProvider();
                }
                else
                {
                    if (Properties.Settings.Default.ConcurrencyAttributesEnabled)
                    {
                        mergeRuleProvider = new AttributeBasedMergeRuleProvider(typesService);
                    }
                    else
                    {
                        throw new ArgumentException("No selected provider for merge rules in snapshot isolation conflicts. Check configuration of merge rule providers.");
                    }
                }
            }
            #endregion

            #region Setup change set provider
            // TODO (nsabo) Provide option for change set safety when context goes offline, OfflineWorkspaces should enable commits when context is back online

            if (Properties.Settings.Default.ChangeSetHistoryFileStorageUsed)
            {
                var indexedFile = new IndexedFileStorage(new FileStream(Properties.Settings.Default.ChangeSetHistoryFileStorageFileName, FileMode.Create), 256, false);
                indexedFile.Serializer = this.objectSerializationService;
                disposables.Add(indexedFile);

                var changeSetProviderStorage = new CachedWriteNodeProviderUnsafe <Guid, object, EdgeData>(
                    new DirectNodeProviderUnsafe <Guid, object, EdgeData>(indexedFile, true),
                    new LimitedDirectNodeProviderUnsafe <Guid, object, EdgeData>(
                        new LimitedMemoryStorageUnsafe <Guid, object>(Properties.Settings.Default.ChangeSetHistoryWriteCacheMinimumCount, Properties.Settings.Default.ChangeSetHistoryWriteCacheMaximumCount), false)
                    );
                disposables.Add(changeSetProviderStorage);

                changeSetProvider = new TrackingChangeSetProvider(changeSetProviderStorage);
            }
            else
            {
                changeSetProvider = new TrackingChangeSetProvider(new DirectNodeProviderUnsafe <Guid, object, EdgeData>(new MemoryStorageUnsafe <Guid, object>(), false));
            }

            #endregion

            var immutableParentProvider = new ParentMapProvider(new DirectNodeProviderUnsafe <Guid, object, EdgeData>(new MemoryStorageUnsafe <Guid, object>(), false), provider, null, false);
            collectedNodesProvider = new CollectedNodesProvider(new DirectNodeProviderUnsafe <Guid, object, EdgeData>(new MemoryStorageUnsafe <Guid, object>(), false), provider);

            commitDataService = new CommitDataService(provider, typesService, snapshotsService, mutableParentProvider, immutableParentProvider, changeSetProvider, new NodeMergeExecutor(mergeRuleProvider, typesService), collectedNodesProvider);

            workspaceExclusiveLockProvider = new WorkspaceExclusiveLockProvider();
            disposables.Add(workspaceExclusiveLockProvider);

            trackingWorkspaceStateProvider = new TrackingWorkspaceStateProvider(workspaceExclusiveLockProvider);

            objectInstancesService = new ObjectInstancesService(provider, typesService);

            subscriptionManagerService = new SubscriptionManagerService(typesService, objectInstancesService);

            workspaceFacade = new WorkspaceFacade(commitDataService, trackingWorkspaceStateProvider, subscriptionManagerService, snapshotsService, workspaceExclusiveLockProvider);

            backupService = new BackupService();

            bool firstRun = snapshotsService.InitializeSnapshots();

            if (firstRun)
            {
                InitializeDefaultSnapshot();
            }
            else
            {
                OptimizeData();
            }

            StaticProxyFacade.Initialize(typesService);
        }
コード例 #18
0
        private static void LogObject(Guid nodeId, Node <Guid, object, EdgeData> node, INodeProvider <Guid, object, EdgeData> nodes, INodeProvider <Guid, object, EdgeData> changes, int tabLevel, Hashtable visited, TypesService typesService)
        {
            var typeId   = typesService.GetInstanceTypeId(node);
            var typeName = typesService.GetTypeFromId(typeId).Name;

            Debug.WriteLine(LogTabs(tabLevel) + nodeId + "(" + typeName + ")");
            Debug.WriteLine(LogTabs(tabLevel) + "Previous=" + node.Previous);

            foreach (var value in node.Values)
            {
                Debug.WriteLine(LogTabs(tabLevel) + typesService.GetMemberName(typeId, value.Key) + "=" + value.Value);
            }

            foreach (var edge in node.Edges)
            {
                if (edge.Value.Data.Semantic == EdgeType.Property)
                {
                    Debug.WriteLine(LogTabs(tabLevel) + typesService.GetMemberName(typeId, (Guid)edge.Value.Data.Data) + "=");
                    LogNodesRecursive(edge.Value.ToNodeId, nodes, changes, tabLevel + 1, visited, typesService);
                }
            }
        }
コード例 #19
0
 public NodeMergeExecutor(IMergeRuleProvider objectAttributeProvider, TypesService typesService)
 {
     this.objectAttributeProvider = objectAttributeProvider;
     this.typesService            = typesService;
 }
コード例 #20
0
        internal static void LogNodesRecursive(Guid nodeId, INodeProvider <Guid, object, EdgeData> nodes, INodeProvider <Guid, object, EdgeData> changes, int tabLevel, Hashtable visited, TypesService typesService)
        {
            if (visited.ContainsKey(nodeId))
            {
                Debug.WriteLine(LogTabs(tabLevel) + nodeId);
                return;
            }

            visited.Add(nodeId, null);

            if (changes.Contains(nodeId))
            {
                var node = changes.GetNode(nodeId, NodeAccess.Read);
                switch (node.NodeType)
                {
                case NodeType.Object:
                    LogObject(nodeId, node, nodes, changes, tabLevel, visited, typesService);
                    break;

                case NodeType.Collection:
                    LogCollection(nodeId, node, nodes, changes, tabLevel, visited, typesService);
                    break;

                case NodeType.Dictionary:
                    LogCollection(nodeId, node, nodes, changes, tabLevel, visited, typesService);
                    break;

                default:
                    Debug.WriteLine(LogTabs(tabLevel) + node.Previous + "->" + nodeId + "[" + node.NodeType + "]");
                    foreach (var edge in node.Edges)
                    {
                        Debug.WriteLine(LogTabs(tabLevel) + edge.Key + "=");
                        LogNodesRecursive(edge.Value.ToNodeId, nodes, changes, tabLevel + 1, visited, typesService);
                    }
                    break;
                }
            }
            else
            {
                Debug.WriteLine(LogTabs(tabLevel) + nodeId);
            }
        }
コード例 #21
0
        private static void LogCollection(Guid nodeId, Node <Guid, object, EdgeData> node, INodeProvider <Guid, object, EdgeData> nodes, INodeProvider <Guid, object, EdgeData> changes, int tabLevel, Hashtable visited, TypesService typesService)
        {
            Edge <Guid, EdgeData> typeEdge = null;

            BPlusTreeOperations.TryFindEdge(nodes, nodeId, new EdgeData(EdgeType.OfType, null), out typeEdge);

            var typeId   = typeEdge.ToNodeId;
            var typeName = typesService.GetTypeFromId(typeId).Name;

            Debug.WriteLine(LogTabs(tabLevel) + nodeId + "(" + typeName + ")");
            Debug.WriteLine(LogTabs(tabLevel) + "Previous=" + node.Previous);


            using (var enumeration = BPlusTreeOperations.GetEnumerator(nodes, nodeId, EdgeType.ListItem))
            {
                while (enumeration.MoveNext())
                {
                    Debug.WriteLine(LogTabs(tabLevel) + enumeration.Current.Data + "=");
                    LogNodesRecursive(enumeration.Current.ToNodeId, nodes, changes, tabLevel + 1, visited, typesService);
                }
            }
        }
コード例 #22
0
 /// <summary>
 /// Creates new instance of GenerationService type
 /// </summary>
 /// <param name="typesService">Type service to use</param>
 public GenerationService(TypesService typesService)
 {
     this.typesService = typesService;
 }
コード例 #23
0
        public AttributeBasedMergeRuleProvider(TypesService typesService)
        {
            this.typesService = typesService;

            Initialize();
        }
コード例 #24
0
 public void SetUp()
 {
     _typesRepo    = new Mock <ITypesRepository>();
     _typesService = new TypesService(_typesRepo.Object);
 }
コード例 #25
0
 /// <summary>
 /// Creates new instance of SubscriptionManagerService type
 /// </summary>
 /// <param name="typesService">Service which manages types</param>
 /// <param name="objectInstancesService">Service which handles object instances</param>
 public SubscriptionManagerService(TypesService typesService, ObjectInstancesService objectInstancesService)
 {
     this.typesService           = typesService;
     this.objectInstancesService = objectInstancesService;
 }