C# IProjectService类代码示例

 public CognateIdentifierOptionsViewModel(SegmentPool segmentPool, IProjectService projectService, EMSoundChangeInducerOptionsViewModel em,
     LexStatOptionsViewModel lexStat)
     : base("Cognacy", "Method", em, lexStat)
 {
     _segmentPool = segmentPool;
     _projectService = projectService;
 }

 public ProjectsController(IProjectService projectService, IDictionaryService dictionaryService, ISprintService spirntService, ApplicationUserManager applicationUserManager)
 {
     _projectService = projectService;
     _dictionaryService = dictionaryService;
     _sprintService = spirntService;
     _applicationUserManager = applicationUserManager;
 }

        public HierarchicalGraphViewModel(IProjectService projectService, IImageExportService exportService, IGraphService graphService)
            : base("Hierarchical Graph")
        {
            _projectService = projectService;
            _exportService = exportService;
            _graphService = graphService;

            _projectService.ProjectOpened += _projectService_ProjectOpened;

            Messenger.Default.Register<ComparisonPerformedMessage>(this, msg =>
            {
                if (_projectService.AreAllVarietiesCompared)
                    Graph = _graphService.GenerateHierarchicalGraph(_graphType, _clusteringMethod, _similarityMetric);
            });
            Messenger.Default.Register<DomainModelChangedMessage>(this, msg =>
            {
                if (msg.AffectsComparison)
                    Graph = null;
            });
            Messenger.Default.Register<PerformingComparisonMessage>(this, msg => Graph = null);

            TaskAreas.Add(new TaskAreaCommandGroupViewModel("Graph type",
                new TaskAreaCommandViewModel("Dendrogram", new RelayCommand(() => GraphType = HierarchicalGraphType.Dendrogram)),
                new TaskAreaCommandViewModel("Tree", new RelayCommand(() => GraphType = HierarchicalGraphType.Tree))));
            TaskAreas.Add(new TaskAreaCommandGroupViewModel("Clustering method",
                new TaskAreaCommandViewModel("UPGMA", new RelayCommand(() => ClusteringMethod = ClusteringMethod.Upgma)),
                new TaskAreaCommandViewModel("Neighbor-joining", new RelayCommand(() => ClusteringMethod = ClusteringMethod.NeighborJoining))));
            TaskAreas.Add(new TaskAreaCommandGroupViewModel("Similarity metric",
                new TaskAreaCommandViewModel("Lexical", new RelayCommand(() => SimilarityMetric = SimilarityMetric.Lexical)),
                new TaskAreaCommandViewModel("Phonetic", new RelayCommand(() => SimilarityMetric = SimilarityMetric.Phonetic))));
            TaskAreas.Add(new TaskAreaItemsViewModel("Other tasks",
                new TaskAreaCommandViewModel("Export graph", new RelayCommand(Export, CanExport))));
            _graphType = HierarchicalGraphType.Dendrogram;
        }

        public XmlFormatterFeature(IProjectService projectService, FeatureSet featureSet)
            : base(projectService)
        {
            this.none = new FeatureItem(
                "None",
                "None",
                "Removes the XML formatter.",
                featureSet == FeatureSet.Mvc6 ? 1 : 3)
            {
                IsSelected = featureSet == FeatureSet.Mvc6
            };
            this.Items.Add(none);

            this.dataContractSerializer = new FeatureItem(
                "DataContractSerializer",
                "DataContractSerializer",
                "Include an XML input and output formatter using the DataContractSerializer.",
                featureSet == FeatureSet.Mvc6 ? 2 : 1)
            {
                IsSelected = featureSet == FeatureSet.Mvc6Api
            };
            this.Items.Add(dataContractSerializer);

            this.xmlSerializer = new FeatureItem(
                "XmlSerializer",
                "XmlSerializer",
                "Include an XML input and output formatter using the XmlSerializer.",
                featureSet == FeatureSet.Mvc6 ? 3 : 2);
            this.Items.Add(xmlSerializer);
        }

 public ProjectsController(IProjectService projectService,
     ILogger logger)
 {
     _projectService = projectService;
     _projectService.UserManager = UserManager;
     _logger = logger;
 }

 public PoorMansAffixIdentifierViewModel(SpanFactory<ShapeNode> spanFactory, SegmentPool segmentPool, IProjectService projectService)
     : base("Automatic stemmer", "Input-Settings#automatic-stemmer")
 {
     _spanFactory = spanFactory;
     _segmentPool = segmentPool;
     _projectService = projectService;
 }

 //, UserBaseRepository userStore)
 public ProjectController(IProjectService projectService, IUserService userService, IProjectTypeRepository projectTypeService)
 {
     _projectService = projectService;
     _userService = userService;
     _projectTypeService = projectTypeService;
     _logger = LogManager.Instance;
 }

        public NodeDetailsViewModel( IEventAggregator eventAggregator, IProjectService<Project> projectService )
        {
            myProjectService = projectService;

            eventAggregator.GetEvent<NodeSelectedEvent>().Subscribe( node => SetNode( node ) );
            eventAggregator.GetEvent<NodeActivatedEvent>().Subscribe( node => ActivateNode( node ) );
        }

        public WordListsViewModel(IProjectService projectService, IDialogService dialogService, IImportService importService,
			IExportService exportService, IAnalysisService analysisService, WordListsVarietyViewModel.Factory varietyFactory)
            : base("Word lists")
        {
            _projectService = projectService;
            _dialogService = dialogService;
            _importService = importService;
            _exportService = exportService;
            _analysisService = analysisService;
            _varietyFactory = varietyFactory;

            Messenger.Default.Register<SwitchViewMessage>(this, HandleSwitchView);
            Messenger.Default.Register<DomainModelChangedMessage>(this, HandleDomainModelChanged);

            _projectService.ProjectOpened += _projectService_ProjectOpened;

            _findCommand = new RelayCommand(Find);

            TaskAreas.Add(new TaskAreaItemsViewModel("Common tasks",
                    new TaskAreaCommandViewModel("Add a new variety", new RelayCommand(AddNewVariety)),
                    new TaskAreaCommandViewModel("Add a new meaning", new RelayCommand(AddNewMeaning)),
                    new TaskAreaCommandViewModel("Find words", _findCommand),
                    new TaskAreaCommandViewModel("Import word lists", new RelayCommand(Import))));

            TaskAreas.Add(new TaskAreaItemsViewModel("Other tasks",
                    new TaskAreaCommandViewModel("Export word lists", new RelayCommand(Export, CanExport)),
                    new TaskAreaCommandViewModel("Remove affixes from words in all varieties", new RelayCommand(RunStemmer, CanRunStemmer))));
            _addNewVarietyCommand = new RelayCommand(AddNewVariety);
            _addNewMeaningCommand = new RelayCommand(AddNewMeaning);
            _importWordListsCommand = new RelayCommand(Import);
            _showGettingStartedCommand = new RelayCommand(ShowGettingStarted);
            _isEmpty = true;
        }

        public static ProjectTermPredefinedTermsViewModel Create(SquareContext db, IProjectService projectService, int projectStepId, int projectId, string loginId)
        {
            Check.Require(db != null, "Square Entities is required.");
            Check.Require(projectService != null, "projectService is required.");
            Check.Require(loginId != null, "loginId is required.");

            var viewModel = new ProjectTermPredefinedTermsViewModel()
                                {
                                    ProjectStep = db.ProjectSteps.Include("Step").Include("Step.SquareType").Where(a => a.Id == projectStepId).Single(),
                                    Project = db.Projects.Where(a => a.Id == projectId).Single()
                                };

            // load the project step
            var projectStep = viewModel.ProjectStep;

            // load all terms used in project
            var projectTerms = db.ProjectTerms.Where(a => a.Project.Id == projectId && a.SquareType.Id == projectStep.Step.SquareType.Id).ToList();

            // load all terms
            var pt = projectTerms.Select(a => a.Term).ToList();

            // terms that have not been used
            var predefinedTerms = db.Terms.Include("Definitions").Where(a => !pt.Contains(a.Name) && a.IsActive && a.SquareType.Id == projectStep.Step.SquareType.Id).ToList();

            viewModel.PredefinedTerms = predefinedTerms;

            return viewModel;
        }

        public JsonFormatterFeature(IProjectService projectService)
            : base(projectService)
        {
            this.camelCase = new FeatureItem(
                "CamelCase",
                "Camel-Case (e.g. camelCase)",
                "The first character of the variable starts with a lower-case. Each word in the variable name after that starts with an upper-case character.",
                1)
            {
                IsSelected = true
            };
            this.Items.Add(this.camelCase);

            this.titleCase = new FeatureItem(
                "TitleCase",
                "Title Case (e.g. TitleCase)",
                "Each word in the variable name starts with an upper-case character.",
                2);
            this.Items.Add(this.titleCase);

            this.none = new FeatureItem(
                "None",
                "None",
                "Removes the JSON formatter.",
                3);
            this.Items.Add(none);
        }

        public VarietiesViewModel(IProjectService projectService, IDialogService dialogService, IAnalysisService analysisService, VarietiesVarietyViewModel.Factory varietyFactory)
            : base("Varieties")
        {
            _projectService = projectService;
            _dialogService = dialogService;
            _analysisService = analysisService;
            _varietyFactory = varietyFactory;

            _projectService.ProjectOpened += _projectService_ProjectOpened;

            _sortPropertyName = "Meaning.Gloss";
            _sortDirection = ListSortDirection.Ascending;

            Messenger.Default.Register<SwitchViewMessage>(this, HandleSwitchView);

            _findCommand = new RelayCommand(Find);

            TaskAreas.Add(new TaskAreaItemsViewModel("Common tasks",
                    new TaskAreaCommandViewModel("Add a new variety", new RelayCommand(AddNewVariety)),
                    new TaskAreaCommandViewModel("Rename variety", new RelayCommand(RenameSelectedVariety, CanRenameSelectedVariety)),
                    new TaskAreaCommandViewModel("Remove variety", new RelayCommand(RemoveSelectedVariety, CanRemoveSelectedVariety)),
                    new TaskAreaCommandViewModel("Find words", _findCommand),
                    new TaskAreaItemsViewModel("Sort words by", new TaskAreaCommandGroupViewModel(
                        new TaskAreaCommandViewModel("Gloss", new RelayCommand(() => SortWordsBy("Meaning.Gloss", ListSortDirection.Ascending))),
                        new TaskAreaCommandViewModel("Form", new RelayCommand(() => SortWordsBy("StrRep", ListSortDirection.Ascending)))))));

            TaskAreas.Add(new TaskAreaItemsViewModel("Other tasks",
                new TaskAreaCommandViewModel("Remove affixes from words", new RelayCommand(RunStemmer, CanRunStemmer))));
        }

 public ExpenditureController(IOutTypeService OutTypeService, IOutAccountService OutAccountService, IProjectService ProjectService, ICustomerService CustomerService)
 {
     _OutTypeService = OutTypeService;
     _OutAccountService = OutAccountService;
     _ProjectService = ProjectService;
     _CustomerService = CustomerService;
 }

 public SetRandomPortsFeature(
     IPortService portService,
     IProjectService projectService)
     : base(projectService)
 {
     this.portService = portService;
 }

 public FrontEndFrameworkFeature(IProjectService projectService)
     : base(projectService, 
           new IFeatureItem[] 
           {
               new FeatureItem(
                   "Bootstrap",
                   "Bootstrap is the most popular HTML, CSS, and JS framework for developing responsive, mobile first projects on the web.",
                   1,
                   "/Boilerplate.Wizard;component/Assets/Bootstrap.png")
               {
                   IsSelected = true
               },
               new FeatureItem(
                   "Zurb Foundation",
                   "The most advanced responsive front-end framework in the world.",
                   2,
                   "/Boilerplate.Wizard;component/Assets/Zurb Foundation.png",
                   true),
               new FeatureItem(
                   "Semantic UI", 
                   "Semantic is a development framework that helps create beautiful, responsive layouts using human-friendly HTML.", 
                   3,
                   "/Boilerplate.Wizard;component/Assets/Semantic UI.png",
                   true)
           })
 {
 }