C# IApplicationContext.Lookup方法代码示例

 public TrafficMapView(IApplicationContext context, List<NetWorkType> netWorkTypeList)
 {
     this.m_ServiceContext = context;
     this.m_NetWorkTypeList = netWorkTypeList;
     this.m_GeoProvider = context.Lookup(typeof(IDataProvider).FullName) as IDataProvider;
     this.m_TrafficMapService = context.Lookup(typeof(ITrafficMapModelService).FullName) as ITrafficMapModelService;
     this.m_GeoDataProvider = new GeoDataObserver(this.m_GeoProvider).GeoProvider;
     this.m_TrafficEvent = ServiceHelper.Lookup<ITrafficEvent>(context);
     this.InitializeComponent();
     this.Init();
 }

 public TrafficMapModelServiceImpl(IApplicationContext context)
 {
     this.m_ServiceContext = context;
     this.m_TrafficMapVectorData = new Huawei.UNet.Traffic.Map.Model.TrafficMapVectorData();
     this.m_EnvMapMgr = new Huawei.UNet.Traffic.Map.Model.EnvTrafficMapMgr(context, this, this.m_TrafficMapVectorData);
     this.m_VecMapMgr = new Huawei.UNet.Traffic.Map.Model.VectorTrafficMapMgr(context, this, this.m_TrafficMapVectorData);
     this.m_CellMapMgr = new Huawei.UNet.Traffic.Map.Model.CellTrafficMapMgr(context, this);
     this.m_TrafficMapMrg = new Huawei.UNet.Traffic.Map.Model.TrafficMapMgr(context);
     IDataProvider subject = context.Lookup(typeof(IDataProvider).FullName) as IDataProvider;
     this.m_GeoDataHandler = new GeoDataObserver(subject);
     this.m_TrafficEvent = context.Lookup(typeof(ITrafficEvent).FullName) as ITrafficEvent;
     IDataProvider provider2 = context.Lookup(typeof(IDataProvider).FullName) as IDataProvider;
 }

 public TrafficMapFunctionImp(IApplicationContext context, TrafficMapView trafficMapView)
 {
     this.m_Context = context;
     this.m_TrafficMapView = trafficMapView;
     this.m_TrafficMapModelService = context.Lookup(typeof(ITrafficMapModelService).FullName) as ITrafficMapModelService;
     this.m_GisPolygonAssist = this.m_TrafficMapModelService.GeoProvider.PolygonRegionAssist;
 }

 public CellUserGenerator(IApplicationContext context)
 {
     this.m_ServiceContext = context;
     this.m_UserCollection = new UserCollection();
     this.m_CellClutterPtsCntDict = new Dictionary<int, Dictionary<short, int>>();
     this.m_CellClutterWeightFactorDict = new Dictionary<int, Dictionary<short, double>>();
     this.m_TrafficModelService = context.Lookup(typeof(ITrafficMapModelService).FullName) as ITrafficMapModelService;
     this.m_PolyAssist = this.m_TrafficModelService.PolygonRegionAssist;
 }

 public void InitStage1(IApplicationContext appContext)
 {
     if (!this.m_NetTypeList.Contains(NetWorkType.CDMA))
     {
         TrafficMapModelServiceImpl mapModelService = new TrafficMapModelServiceImpl(appContext);
         TrafficMapServiceImpl service = new TrafficMapServiceImpl(mapModelService, appContext);
         appContext.RegisterService(mapModelService);
         appContext.RegisterService(service);
         (appContext.Lookup(typeof(IAppAgent).FullName) as IAppAgent).AddApplicationVectorLayer(mapModelService.TrafficMapVectorData);
     }
 }

 public VectorTrafficMap(IApplicationContext context)
 {
     ITrafficMapModelService service = context.Lookup(typeof(ITrafficMapModelService).FullName) as ITrafficMapModelService;
     this.m_MapIndex = service.VectorTrafficMapMgr.VectorTrafficMapList.Count;
     this.Name = TrafficMapResource.TRAFFICMAP_VECTORMAP + this.m_MapIndex.ToString();
     this.m_ServiceContext = context;
     this.m_MapIndex++;
     Random random = new Random();
     this.m_TrafficMapColor = Color.FromArgb(120, random.Next(0, 0x100), random.Next(0, 0x100), random.Next(0, 0x100));
     this.Init();
 }

 public CellTrafficMapMgr(IApplicationContext context, ITrafficMapModelService mservice)
 {
     this.m_ModelService = mservice;
     this.m_ServiceContext = context;
     this.m_ErrorMessageDic = new Dictionary<string, string>();
     this.m_ErrorMessageDic.Add(TrafficMapResource.TRAFFICMAP_NAME_EXIST, TrafficMapResource.TRAFFICMAP_MAP_EXIST);
     this.m_ErrorMessageDic.Add(TrafficMapResource.TRAFFICMAP_BELOWZERO, TrafficMapResource.TRAFFICMAP_VALUE_LARGE_ZERO);
     this.m_ErrorMessageDic.Add(TrafficMapResource.TRAFFICMAP_LARGEHUNDRED, TrafficMapResource.TRAFFICMAP_VALUE_SAMLL_HUNDRAND);
     this.m_ErrorMessageDic.Add(TrafficMapResource.TRAFFICMAP_NULL, TrafficMapResource.TRAFFICMAP_VALUE_NULL);
     ITrafficForMap map = context.Lookup(typeof(ITrafficForMap).FullName) as ITrafficForMap;
     map.CanMobilityDeletingEvent += new EventHandler<CancellerEventArgs>(this.DelMobilityEvent);
     map.CanServiceDeletingEvent += new EventHandler<CancellerEventArgs>(this.DelServiceEvent);
     map.CanTerminalDeletingEvent += new EventHandler<CancellerEventArgs>(this.DelTerminalEvent);
 }

 public MapClutterHelper(GeoPolygonRegion poly, IGeoPolygonAssist polyAssist, Dictionary<short, ClutterData> clutterDataDict, IApplicationContext appContext, bool isFixure)
 {
     this.m_ClutterAreaPercentDict = new Dictionary<short, double>();
     this.m_ClutterPtsCntDict = new Dictionary<short, int>();
     this.m_CluttersId = new List<short>();
     this.m_ClutterWeightFactorDict = new Dictionary<short, double>();
     this.m_ClutterDataDict = clutterDataDict;
     this.EventViewService = appContext.Lookup(typeof(IEventViewService).FullName) as IEventViewService;
     this.EventViewService.SetProgressScope(TrafficMapResource.TRAFFICMAP_GENUSER, 0, 100);
     this.m_ClutterPtsCntDict = polyAssist.GetClutterCountDict(poly, new SimulationProgressHandle(this.ReportProgrss), 5, 0x55, TrafficMapResource.TRAFFICMAP_GENUSER, !isFixure);
     this.EventViewService.ResetProgress(TrafficMapResource.TRAFFICMAP_GENUSER);
     this.GetClutterIDs();
     this.GetClutterAreaPercentDict();
     this.GetClutterWeightFactorDict();
 }

 public void Load(IApplicationContext context)
 {
     try
     {
         XmlReaderSettings settings = new XmlReaderSettings {
             ProhibitDtd = false,
             ValidationType = ValidationType.DTD
         };
         XmlReader reader = XmlReader.Create(this.PLUGIN_CONFIG, settings);
         XmlDocument document = new XmlDocument();
         document.Load(reader);
         XmlNodeList childNodes = document.ChildNodes;
         XmlNode node = null;
         foreach (XmlNode node2 in childNodes)
         {
             if (node2.Name.Equals("TrafficMap"))
             {
                 node = node2;
                 break;
             }
         }
         if (node.ChildNodes != null)
         {
             XmlNodeList list2 = node.ChildNodes;
             foreach (XmlNode node3 in list2)
             {
                 if (node3.Name.Equals("CoverageInfo"))
                 {
                     string serviceName = node3.InnerText.Trim();
                     ITrafficMapCoveragePlugin item = context.Lookup(serviceName) as ITrafficMapCoveragePlugin;
                     this.m_PluginList.Add(item);
                 }
             }
         }
     }
     catch (Exception exception)
     {
         WriteLog.Logger.Error(exception.StackTrace);
         throw exception;
     }
 }

 public CellMapPropertiesFrm(IApplicationContext context, List<NetWorkType> netTypeList)
 {
     this.m_AllTerminal = new Dictionary<string, Terminal>();
     this.m_AllMobility = new Dictionary<string, Mobility>();
     this.m_CellNamesInLowercase = new List<string>();
     this.m_ServiceContext = null;
     this.m_TrafficService = null;
     this.modelService = null;
     this.m_CellDataGridViewDict = new Dictionary<int, Dictionary<int, List<object>>>();
     this.inNode = null;
     this.m_ServiceList = null;
     this.m_TerminalList = null;
     this.m_OldMapName = string.Empty;
     this.components = null;
     this.m_ServiceContext = context;
     this.m_TrafficService = context.Lookup(typeof(ITrafficService).FullName) as ITrafficService;
     this.modelService = context.Lookup(typeof(ITrafficMapModelService).FullName) as ITrafficMapModelService;
     this.m_TrafficMapAutomation = context.Lookup(typeof(ITrafficMapFunction).FullName) as ITrafficMapFunction;
     this.m_netWorkTypeList = netTypeList;
     this.m_TrafficForMap = this.m_ServiceContext.Lookup(typeof(ITrafficForMap).FullName) as ITrafficForMap;
     this.InitializeComponent();
     this.InitCellMap();
     this.m_OldMapName = this.m_Map.Name;
     this.m_IsNodeAdded = false;
     this.Text = TrafficMapResource.TRAFFICMAP_CELL_PROPERTY;
     this.LoadCellMapProperty();
     this.btnApply.Enabled = false;
 }

 public void InitStage1(IApplicationContext appContext)
 {
     if (!this.m_NetWorkTypeList.Contains(NetWorkType.CDMA))
     {
         TrafficServiceImpl impl = new TrafficServiceImpl(appContext, this.m_NetWorkType);
         this.m_Model = impl.TrafficColModel;
         this.m_TrafficService = appContext.Lookup(typeof(ITrafficService).FullName) as ITrafficService;
         this.m_TrafficInterface = new TrafficForNetEntity(appContext, this.m_Model);
         this.m_TrafficForMapInterface = new TrafficForMap(appContext, this.m_Model);
         this.m_TrafficForApp = new TrafficForApplication(appContext, this.m_Model);
         CalMcsEfficiency service = new CalMcsEfficiency(appContext, this.m_Model);
         appContext.RegisterService(this.m_TrafficInterface);
         appContext.RegisterService(this.m_TrafficForMapInterface);
         appContext.RegisterService(this.m_TrafficForApp);
         appContext.RegisterService(service);
         this.m_appContext = appContext;
         this.m_Antennas = ServiceHelper.Lookup<INetAntenna<AntennaEntity>>(appContext);
         this.m_SerializeHelper = new SerializedHelper(this.m_Model, this.m_TrafficSerializedData, this.m_NetWorkTypeList);
         this.InitManagement();
         this.InitExportExcelDic();
     }
 }

 private void InitParam(IApplicationContext context)
 {
     this.m_ServiceContext = context;
     this.m_TrafficMapService = context.Lookup(typeof(ITrafficMapModelService).FullName) as ITrafficMapModelService;
     this.m_TrafficModelService = this.m_ServiceContext.Lookup(typeof(ITrafficService).FullName) as ITrafficService;
     this.m_TrafficMapAutomation = ServiceHelper.Lookup<ITrafficMapFunction>(this.m_ServiceContext);
     this.InitHandleMap();
 }