public UserController(IObjectFactory objectFactory) { _userViewService = objectFactory.Create <IUserViewService>(); _userModifyService = objectFactory.Create <IUserModifyService>(); _userRoleViewService = objectFactory.Create <IUserRoleViewService>(); _credentionalViewService = objectFactory.Create <ICredentionalViewService>(); }
public OrderController(IObjectFactory objectFactory) { _userViewService = objectFactory.Create <IUserViewService>(); _orderModifyService = objectFactory.Create <IOrderModifyService>(); _orderViewService = objectFactory.Create <IOrderViewService>(); _orderTypeViewService = objectFactory.Create <IOrderTypeViewService>(); }
private static void SetFromMapRendererToRasterLayer(IRasterLayer rasterLayer, IObjectFactory objFactory, string mapLayerName) { MapLayersManager layersManager = new MapLayersManager(_map); var fromMapRasterLayer = EsriTools.GetLayer(mapLayerName, _map.FocusMap) as IRasterLayer; if (fromMapRasterLayer == null) { _layersWithDefaultRenderer.Add(rasterLayer.Name); return; } try { Type renderType = typeof(SimpleRendererClass); string typeRenderID = renderType.GUID.ToString("B"); var symbol = (ISimpleRenderer)objFactory.Create(typeRenderID); var objCopy = (IObjectCopy)objFactory.Create("esriSystem.ObjectCopy"); var copyS = objCopy.Copy(fromMapRasterLayer.Renderer) as IRasterRenderer; rasterLayer.Renderer = copyS; } catch (Exception ex) { _layersWithDefaultRenderer.Add(rasterLayer.Name); logger.WarnEx($"Cannot set rendrer from map for {rasterLayer.Name} layer. Exception: {ex.Message}"); } }
private void LoadApplicationDefinition(IAppValues appValues, IBindingService bindingService, IElementTypeMapping elementTypeMapping, IObjectFactory objectFactory) { try { XxElement element; using (var stream = GetType().Assembly.GetManifestResourceStream(GetType().Assembly.GetName().Name + ".App.xml")) { var parser = objectFactory.Create <XxFileParser>(elementTypeMapping); element = parser.Parse(stream); } var scopeBuilder = objectFactory.Create <IScopeBuilder>(); scopeBuilder .WithInstance(elementTypeMapping).As <IElementTypeMapping>() .WithInstance(appValues).As <IAppValues>() .WithInstance(bindingService).As <IBindingService>(); var services = scopeBuilder.Build(); var defObjectFactory = services.GetService <IObjectFactory>().Create <XxDefinitionObjectFactory>(); defObjectFactory.CreateObject <ApplicationElement>(element); } catch (Exception ex) { Console.WriteLine(ex); throw; } }
private void btnDrive_Click(object sender, EventArgs e) { this.Cursor = Cursors.WaitCursor; try { IObjectFactory objFactory = m_application as IObjectFactory; //Use reflection to get ClsID of ShapefileWorkspaceFactory Type shpWkspFactType = typeof(ShapefileWorkspaceFactoryClass); string typeClsID = shpWkspFactType.GUID.ToString("B"); string shapeFile = System.IO.Path.GetFileNameWithoutExtension(txtShapeFilePath.Text); string fileFolder = System.IO.Path.GetDirectoryName(txtShapeFilePath.Text); IWorkspaceFactory workspaceFactory = (IWorkspaceFactory)objFactory.Create(typeClsID); IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspaceFactory.OpenFromFile(fileFolder, 0); //(@"C:\data\test", 0); //Create the layer IFeatureLayer featureLayer = (IFeatureLayer)objFactory.Create("esriCarto.FeatureLayer"); featureLayer.FeatureClass = featureWorkspace.OpenFeatureClass(shapeFile); // ("worldgrid"); featureLayer.Name = featureLayer.FeatureClass.AliasName; //Add the layer to document IBasicDocument document = (IBasicDocument)m_application.Document; document.AddLayer(featureLayer); document.UpdateContents(); } catch { } //Or make sure it is a valid shp file first this.Cursor = Cursors.Default; }
private static IGeoFeatureLayer CreateLayerCopy(IFeatureLayer layer, IObjectFactory objFactory) { var workspacePath = GetWorkspacePathForLayer(layer); Type factoryType = Type.GetTypeFromProgID("esriDataSourcesGDB.FileGDBWorkspaceFactory"); string typeFactoryID = factoryType.GUID.ToString("B"); IWorkspaceFactory workspaceFactory = (IWorkspaceFactory)objFactory.Create(typeFactoryID); IFeatureWorkspace calcWorkspace = (IFeatureWorkspace)workspaceFactory.OpenFromFile(workspacePath, 0); var featureLayer = (IFeatureLayer)objFactory.Create("esriCarto.FeatureLayer"); var featureClassC = calcWorkspace.OpenFeatureClass(layer.FeatureClass.AliasName); featureLayer.FeatureClass = featureClassC; featureLayer.Name = layer.Name; var arcMapLayerDefinition = layer as IFeatureLayerDefinition2; var layerDefinition = featureLayer as IFeatureLayerDefinition2; layerDefinition.DefinitionExpression = arcMapLayerDefinition.DefinitionExpression; IGeoFeatureLayer geoArcMapLayer = layer as IGeoFeatureLayer; IGeoFeatureLayer geoFL = featureLayer as IGeoFeatureLayer; geoFL.Renderer = geoArcMapLayer.Renderer; return(geoFL); }
bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, Func <IParser, Type, object> nestedObjectDeserializer, out object value) { Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(IDictionary <, >)); Type tKey; Type tValue; IDictionary dictionary; if (implementedGenericInterface != null) { Type[] genericArguments = implementedGenericInterface.GetGenericArguments(); tKey = genericArguments[0]; tValue = genericArguments[1]; value = _objectFactory.Create(expectedType); dictionary = (value as IDictionary); if (dictionary == null) { dictionary = new GenericDictionaryToNonGenericAdapter(value, implementedGenericInterface); } } else { if (!typeof(IDictionary).IsAssignableFrom(expectedType)) { value = null; return(false); } tKey = typeof(object); tValue = typeof(object); value = _objectFactory.Create(expectedType); dictionary = (IDictionary)value; } DeserializeHelper(tKey, tValue, parser, nestedObjectDeserializer, dictionary); return(true); }
bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, Func <IParser, Type, object> nestedObjectDeserializer, out object value) { bool canUpdate = true; Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(ICollection <>)); Type tItem; IList list; if (implementedGenericInterface != null) { Type[] genericArguments = implementedGenericInterface.GetGenericArguments(); tItem = genericArguments[0]; value = _objectFactory.Create(expectedType); list = (value as IList); if (list == null) { Type implementedGenericInterface2 = ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(IList <>)); canUpdate = (implementedGenericInterface2 != null); list = new GenericCollectionToNonGenericAdapter(value, implementedGenericInterface, implementedGenericInterface2); } } else { if (!typeof(IList).IsAssignableFrom(expectedType)) { value = null; return(false); } tItem = typeof(object); value = _objectFactory.Create(expectedType); list = (IList)value; } DeserializeHelper(tItem, parser, nestedObjectDeserializer, list, canUpdate); return(true); }
public HomeController(IObjectFactory objectFactory) { _userViewService = objectFactory.Create <IUserViewService>(); _productViewService = objectFactory.Create <IProductViewService>(); _groupViewService = objectFactory.Create <IProductGroupViewService>(); _categoryViewService = objectFactory.Create <IProductCategoryViewService>(); }
internal static void OpenProfilesSetIn3D(ArcSceneArguments layers) { OpenArcScene(); try { IObjectFactory objFactory = m_application as IObjectFactory; Type rasterLayerType = typeof(RasterLayerClass); string typeRasterLayerID = rasterLayerType.GUID.ToString("B"); var elevationRasterLayer = (IRasterLayer)objFactory.Create(typeRasterLayerID); elevationRasterLayer.CreateFromFilePath(layers.DemLayer); var layer = (ILayer)elevationRasterLayer; var surface = (IRasterSurface)objFactory.Create("esrianalyst3d.RasterSurface"); surface.PutRaster(elevationRasterLayer.Raster, 0); var functionalSurface = (IFunctionalSurface)surface; var line3DLayer = CreateLayer(layers.Line3DLayer, objFactory); var point3DLayer = CreateLayer(layers.Point3DLayer, objFactory); var polygon3DLayer = CreateLayer(layers.Polygon3DLayer, objFactory); var polygonLayerEffects = (ILayerEffects)polygon3DLayer; polygonLayerEffects.Transparency = 50; var document = (IBasicDocument)m_application.Document; SetSurface3DProperties(layer, objFactory, functionalSurface); SetLine3DProperties(line3DLayer, objFactory, functionalSurface); SetFeatures3DProperties(point3DLayer, objFactory); SetFeatures3DProperties(polygon3DLayer, objFactory); document.AddLayer(layer); document.AddLayer(line3DLayer); document.AddLayer(point3DLayer); document.AddLayer(polygon3DLayer); foreach (var extraLayer in layers.AdditionalLayers) { var featureLayer = CreateLayerCopy((IFeatureLayer)extraLayer, objFactory); document.AddLayer(featureLayer); } document.UpdateContents(); document.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, VisibilityColorsRender(line3DLayer, objFactory), document.ActiveView.Extent); document.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, VisibilityColorsRender(polygon3DLayer, objFactory), document.ActiveView.Extent); document.UpdateContents(); } catch (Exception ex) { } }
public IEnumerable <Ticket> GetAllTickets(Guid userId) { var results = _ticketRepository.Find(x => x.UserID == userId); var tickets = results.Select(ticketEntity => _objectFactory.Create <Ticket>(ticketEntity)); return(tickets); }
public void TestGateway_with_ref_constructor() { var gateway = factory.Create <ITestGateway>("TestGateway"); Assert.That(gateway, Is.Not.Null); var xmlServiceClient = (XmlServiceClient)gateway.ServiceClient; Assert.That(xmlServiceClient.BaseUri, Is.EqualTo("http://mock.org/service.svc")); }
/// <summary> /// Gets the user. /// </summary> /// <param name="request">The request.</param> /// <param name="context">The context.</param> /// <returns>A Task.</returns> public override async Task <UserResponse> GetUsers(UserRequest request, ServerCallContext context) { var user = await _userDal.GetUsers(request.Ids); var userResponse = new UserResponse(); foreach (var item in user) { var obj = _objectFactory.Create <UserEntrity, Proto.UserRpc.User>(item); userResponse.Users.Add(obj); } return(userResponse); }
public async Task <IActionResult> AddUser([FromBody] ReqAddUserModel user) { var entiry = objectFactory.Create <ReqAddUserModel, UserEntrity>(user); var r = await userDal.InsertAndGet(entiry); if (r == null) { return(this.JsonError(500, "添加错误")); } var rsp = objectFactory.Create <UserEntrity, RspUserModel>(r); return(this.JsonData(rsp)); }
public void Create_BasicWebServiceClientTest() { var client = factory.Create <Soap11ServiceClient>("Soap11ServiceClient"); Assert.IsNotNull(client); Assert.AreEqual("http://mock.org/service.svc", client.Uri); }
private Task <Image> LoadImageFromWeb(string uri) { if (runningTasks.TryGetValue(uri, out var runningTask)) { return(runningTask); } var task = Task.Run(async() => { var request = WebRequest.Create(uri); Stream dataStream = null; using (var response = await request.GetResponseAsync()) { dataStream = new MemoryStream(); using (var respStream = response.GetResponseStream()) { await respStream.CopyToAsync(dataStream); } dataStream.Seek(0, SeekOrigin.Begin); } var image = await systemDispatcher.InvokeAsync(() => { try { return(objectFactory.Create <Image>(dataStream)); } finally { dataStream.Dispose(); } }); image = AddImage(uri, image); runningTasks.TryRemove(uri, out var _); return(image); }); if (runningTasks.TryGetValue(uri, out runningTask)) { return(runningTask); } runningTasks.TryAdd(uri, task); return(task); }
public BuffProto Create(string resName, Resource res) { var image = imageFactory.Create(resName, res); var tooltip = res.GetLayer <TooltipLayer>(); return(new BuffProto(image, tooltip?.Text)); }
private static void SetFromMapRendererToFeatureLayer(IFeatureLayer featureLayer, IObjectFactory objFactory, string featureClassName) { MapLayersManager mapLayersManager = new MapLayersManager(_map); var layerName = mapLayersManager.GetLayerAliasByFeatureClass(featureClassName); if (!String.IsNullOrEmpty(layerName)) { var fromMapGeoFeatureLayer = EsriTools.GetLayer(layerName, _map.FocusMap) as IGeoFeatureLayer; if (fromMapGeoFeatureLayer == null) { _layersWithDefaultRenderer.Add(featureLayer.Name); return; } var geoFeatureLayer = featureLayer as IGeoFeatureLayer; try { Type renderType = typeof(SimpleRendererClass); string typeRenderID = renderType.GUID.ToString("B"); var objCopy = (IObjectCopy)objFactory.Create("esriSystem.ObjectCopy"); var rendereCopy = objCopy.Copy(fromMapGeoFeatureLayer.Renderer) as IFeatureRenderer; geoFeatureLayer.Renderer = rendereCopy; } catch (Exception ex) { _layersWithDefaultRenderer.Add(featureLayer.Name); logger.WarnEx($"Cannot set rendrer from map for {featureLayer.Name} layer. Exception: {ex.Message}"); } } }
private static void SetVisibilitySessionRaster3DProperties(IRasterLayer rasterLayer, IObjectFactory objFactory, IFunctionalSurface surface, bool isDrapperyLayer = false) { var properties3D = (I3DProperties3)objFactory.Create("esrianalyst3d.Raster3DProperties"); properties3D.BaseOption = esriBaseOption.esriBaseSurface; properties3D.BaseSurface = surface; if (!isDrapperyLayer) { properties3D.OffsetExpressionString = "2"; properties3D.DepthPriorityValue = 1; } else { properties3D.DepthPriorityValue = 9; } properties3D.ZFactor = _zFactor; properties3D.RenderVisibility = esriRenderVisibility.esriRenderAlways; properties3D.RenderMode = esriRenderMode.esriRenderCache; properties3D.TextureDownsamplingFactor = 0.7; properties3D.AlphaThreshold = 0.1; properties3D.RenderRefreshRate = 0.75; properties3D.Illuminate = true; ILayerExtensions layerExtensions = (ILayerExtensions)rasterLayer; layerExtensions.AddExtension(properties3D); properties3D.Apply3DProperties(rasterLayer); }
public XxElement Parse(Assembly assembly, string path, bool cache = false) { var key = Tuple.Create(assembly, path); if (this.cache.TryGetValue(key, out var element)) { return(element); } try { using (var stream = assembly.GetManifestResourceStream(path)) { var parser = objectFactory.Create <XxFileParser>(); element = parser.Parse(stream); } if (cache) { this.cache.TryAdd(key, element); } } catch (Exception ex) { Console.WriteLine(ex); throw; } return(element); }
private static IGeometry BuildMultiPatch(WktText wkt, IObjectFactory objectFactory) { var multiPatch = (IGeometryCollection)objectFactory.Create("esriGeometry.MultiPatch"); //IGeometryCollection multiPatch = new MultiPatchClass(); foreach (var polygonString in wkt.Token.Tokens) { bool isOuter = true; foreach (var ringString in polygonString.Tokens) { var ring = BuildRing(ringString, wkt, objectFactory); multiPatch.AddGeometry(ring); ((IMultiPatch)multiPatch).PutRingType(ring, isOuter ? esriMultiPatchRingType.esriMultiPatchOuterRing : esriMultiPatchRingType.esriMultiPatchInnerRing); isOuter = false; } } ((ITopologicalOperator)multiPatch).Simplify(); var geometry = multiPatch as IGeometry; MakeZmAware(geometry, wkt.HasZ, wkt.HasM); return(geometry); }
/// <summary> /// Loads the plugin. /// </summary> /// <param name="pluginConfigPath">The plugin config path.</param> /// <returns>A ValueTask.</returns> public async ValueTask <IPlugins> LoadPlugin(string pluginConfigPath) { IPluginsLoadContext locadContext = null; try { var pluginConfig = jsonUtil.Get <PluginConfig>(pluginConfigPath); var pluginDir = Path.GetDirectoryName(pluginConfigPath); var pluginPath = Path.Combine(pluginDir, pluginConfig.AssemblyName); locadContext = pluginLoadContextProvider.CreateLoadContext(pluginPath); var assemably = locadContext.LoadAssembly(new AssemblyName(Path.GetFileNameWithoutExtension(pluginPath))); var allPluginTypes = reflectorUtil.GetTypeOfAbsoluteBase(assemably, typeof(Plugins)).ToList(); if (allPluginTypes.Count == 0) { throw new Exception($"{pluginConfig.AssemblyName}请实现基于Plugins的插件类"); } if (allPluginTypes.Count == 2) { throw new Exception($"{ pluginConfig.AssemblyName}存在多个Plugins实现类"); } var pluginType = allPluginTypes[0]; var plugin = (Plugins)objectFactory.Create(pluginType); SetPluginValues(pluginDir, pluginConfig, assemably, ref plugin); pluginContextDic.TryAdd(pluginConfig.Key, locadContext); return(plugin); } catch (Exception e) { log.LogError(e, e.Message); locadContext?.UnLoad(); throw; } }
/// <summary> /// Updates the user. /// </summary> /// <param name="id">The id.</param> /// <param name="record">The record.</param> /// <returns>A ValueTask.</returns> public async ValueTask <int> UpdateUser(string id, IRecord record) { var useEntiry = objectFactory.Create <UserEntrity>(record); var r = await repository.UpdateAsync(id, useEntiry); return(r); }
bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func <EventReader, Type, object> nestedObjectDeserializer, out object value) { if (!typeof(IList).IsAssignableFrom(expectedType)) { value = false; return(false); } reader.Expect <SequenceStart>(); var list = (IList)_objectFactory.Create(expectedType); while (!reader.Accept <SequenceEnd>()) { var item = nestedObjectDeserializer(reader, typeof(object)); var promise = item as IValuePromise; if (promise == null) { list.Add(item); } else { var index = list.Count; list.Add(null); promise.ValueAvailable += v => list[index] = v; } } value = list; reader.Expect <SequenceEnd>(); return(true); }
public async Task <IActionResult> UpdateOraginzation([FromQuery] string oraginzationId, [FromBody] ReqUpdateOrgModel model) { var record = _objectFactory.Create(model); var r = await _orgsDal.UpdateOrg(oraginzationId, record); return(this.JsonData(r)); }
internal virtual IAccountInternal CreateAccount() { var account = _objectFactory.Create <IAccountInternal>(); account.IsLocal = false; return(account); }
public ValidationResultModel Validate(ValidationCommand validationCommand) { if (validationCommand == null) { throw new ArgumentNullException("validationCommand"); } if (!Validators.ContainsKey(validationCommand.ValidatorName)) { return(new ValidationResultModel { IsValidatorFound = false }); } try { var validatorType = Validators[validationCommand.ValidatorName]; var validator = _objectFactory.Create(validatorType) as IObjectValidator; if (validator == null) { throw new InvalidOperationException("Validator is null."); } var objectToValidate = _objectConverter.Convert(validationCommand.Value, validator.ValidatedType); IList <ValidationFault> result = validator.Validate(objectToValidate); return(new ValidationResultModel { ValidationFaults = result, IsValidatorFound = true }); } catch (Exception ex) { throw new ServiceException("Can't validate requested object", ex); } }
/// <summary> /// Preenche o dicionário especificado com novas instâncias, criadas /// pelo factory especificado. As chaves de cada entrada são fornecidas /// pelo enumerável. /// </summary> public static void FillDictionary(IDictionary dictionary, IEnumerable enumerable, IObjectFactory factory) { foreach (object key in enumerable) { dictionary.Add(key, factory.Create()); } }
bool INodeDeserializer.Deserialize(IParser reader, Type expectedType, Func <IParser, Type, object> nestedObjectDeserializer, out object value) { var mapping = reader.Allow <MappingStart>(); if (mapping == null) { value = null; return(false); } value = _objectFactory.Create(expectedType); while (!reader.Accept <MappingEnd>()) { var propertyName = reader.Expect <Scalar>(); var property = _typeDescriptor.GetProperty(expectedType, value, propertyName.Value, _ignoreUnmatched); if (property == null) { reader.SkipThisAndNestedEvents(); continue; } var propertyValue = nestedObjectDeserializer(reader, property.Type); if (!(propertyValue is IValuePromise propertyValuePromise)) { var convertedValue = TypeConverter.ChangeType(propertyValue, property.Type); property.Write(value, convertedValue); }
/// <summary> /// Initializes a new instance of the <see cref="PluginLoader"/> class. /// </summary> /// <param name="directory">The directory.</param> /// <param name="jsonUtil">The json util.</param> /// <param name="pluginLoadContextProvider"></param> /// <param name="log">The log.</param> /// <param name="reflectorUtil">The reflector util.</param> /// <param name="objectFactory">The object factory.</param> /// <param name="pluginManagers"></param> /// <param name="moduleLoader"></param> /// <param name="loadActions"></param> /// <param name="unLoadActions"></param> /// <param name="applicationOption"></param> /// <param name="hostEnvironment"></param> public PluginLoader(ISysDirectory directory, IJsonUtil jsonUtil, IPluginLoadContextProvider pluginLoadContextProvider, ILogger <PluginLoader> log, IReflectorUtil reflectorUtil, IObjectFactory objectFactory, IPluginManagers pluginManagers, IModuleLoader moduleLoader, IEnumerable <IPluginLoadAction> loadActions, IEnumerable <IPluginUnLoadAction> unLoadActions, ApplicationOption applicationOption, IHostEnvironment hostEnvironment) { this.directory = directory; this.jsonUtil = jsonUtil; this.pluginLoadContextProvider = pluginLoadContextProvider; this.log = log; pluginContextDic = objectFactory.Create <ConcurrentDictionary <Guid, IPluginsLoadContext> >(); this.reflectorUtil = reflectorUtil; this.objectFactory = objectFactory; _pluginManagers = pluginManagers; _moduleLoader = moduleLoader; _loadActions = loadActions; _unLoadActions = unLoadActions; _applicationOption = applicationOption; _hostEnvironment = hostEnvironment; }
public DependentPersonViewModel(IObjectFactory<IDependentPerson> personFactory) { this.Person = personFactory.Create(); }
/// <summary> /// Preenche o dicionário especificado com novas instâncias, criadas /// pelo factory especificado. As chaves de cada entrada são fornecidas /// pelo enumerável. /// </summary> public static void FillDictionary(IDictionary dictionary, IEnumerable enumerable, IObjectFactory factory) { foreach (object key in enumerable) dictionary.Add(key, factory.Create()); }