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());
}
