/// <summary>
/// 确认插件是否已激活
/// </summary>
/// <param name="bundles"></param>
private void EnsureBundlesActive(IBundle[] bundles)
{
IServiceReference reference = context.GetServiceReference(typeof(IStartLevel).FullName);
var startService = context.GetService <IStartLevel>(reference);
try
{
for (int i = 0; i < bundles.Length; i++)
{
if (bundles[i].State != BundleState.Active)
{
if (bundles[i].State == BundleState.Installed)
{
// Log that the bundle is not resolved
continue;
}
//// check that the startlevel allows the bundle to be active (111550
//if (startService != null && (startService.GetBundleStartLevel(bundles[i]) <= startService.StartLevel))
//{
// // Log that the bundle's level
//}
}
}
}
finally
{
context.UngetService(reference);
}
}
/// <summary>
/// 停止
/// </summary>
internal void Stop()
{
//移除服务监听器
foreach (IServiceListener listener in serviceListenerList)
{
((IFrameworkListener)framework).RemoveServiceListener(listener);
}
serviceListenerList.Clear();
//移除Bundle监听器
foreach (IBundleListener listener in bundleListenerList)
{
((IFrameworkListener)framework).RemoveBundleListener(listener);
}
bundleListenerList.Clear();
//移除Extension监听器
foreach (IExtensionListener listener in extensionListenerList)
{
((IFrameworkListener)framework).RemoveExtensionListener(listener);
}
extensionListenerList.Clear();
//移除已注册的服务
foreach (IServiceReference reference in serviceReferenceList)
{
((IFrameworkService)framework).UnRegisterService(reference);
}
serviceReferenceList.Clear();
//取消使用正在使用的服务
IServiceReference[] bundleUsingServiceReferences = new IServiceReference[bundleUsingServiceReferenceList.Count];
bundleUsingServiceReferenceList.CopyTo(bundleUsingServiceReferences, 0);
foreach (IServiceReference reference in bundleUsingServiceReferences)
{
UnGetService(reference);
}
bundleUsingServiceReferenceList.Clear();
}
/// <summary>
/// Lookups the service references.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>IServiceReference[].</returns>
/// Performs a lookup for ServiceReferences that are bound to this
/// ServiceRegistry using the specified BundleContext.
/// @param context The BundleContext to lookup the ServiceReferences on.
/// @return An array of all matching ServiceReferences or null if none
/// exist.
public IServiceReference[] LookupServiceReferences(IBundleContext context)
{
int size;
List <IServiceReference> references;
List <IServiceRegistration> serviceRegs = (List <IServiceRegistration>)PublishedServicesByContext[context];
if (serviceRegs == null)
{
return(null);
}
size = serviceRegs.Count;
if (size == 0)
{
return(null);
}
references = new List <IServiceReference>();
for (int i = 0; i < size; i++)
{
IServiceRegistration registration = (IServiceRegistration)serviceRegs[i];
IServiceReference reference = registration.GetReference();
references.Add(reference);
}
if (references.Count == 0)
{
return(null);
}
return((IServiceReference[])references.ToArray());
}
public override bool SetInstance(IServiceReference serviceReference)
{
//
// Ha nincs factory akkor amugy sem lehet peldanyositani a szervizt tok mind1 mi az.
//
if (Factory is null)
{
throw new InvalidOperationException(Resources.NOT_PRODUCIBLE);
}
//
// Peldanyositas utan ellenorizzuk a tipust (Factory, Proxy, stb visszaadhat vicces dolgokat).
//
// TBD: Vajon fel kene szabaditani a szervizpeldanyt ha gond vt?
//
object instance = Factory(serviceReference.RelatedInjector !, Interface);
if (!Interface.IsInstanceOfType(instance))
{
throw new InvalidCastException(string.Format(Resources.Culture, Resources.INVALID_INSTANCE, Interface));
}
serviceReference.Value = instance;
SaveReference(serviceReference);
State |= ServiceEntryStates.Instantiated;
return(true);
}
public static DotGraph AsDotGraph(this IServiceReference serviceReference)
{
DotGraph graph = new();
Process(serviceReference);
return(graph);
void Process(IServiceReference serviceReference)
{
DotGraphNode from = serviceReference.AsDotGraphNode();
graph.Nodes.Add(from);
foreach (IServiceReference dep in serviceReference.Dependencies)
{
DotGraphNode to = dep.AsDotGraphNode();
DotGraphEdge edge = new(from, to);
//
// Korkoros referencia eseten ne legyen S.O.E.
//
if (!graph.Edges.Add(edge))
{
continue;
}
graph.Nodes.Add(to);
Process(dep);
}
}
}
/// <summary>
/// 取消调用指定服务引用的服务实例
/// </summary>
/// <param name="reference">服务引用</param>
/// <param name="bundle">调用服务的Bundle</param>
/// <returns>是否成功</returns>
public bool UnGetService(IServiceReference reference, IBundle bundle)
{
if (usingServiceBundleDict.ContainsKey(reference))
{
return(usingServiceBundleDict[reference].Remove(bundle));
}
return(false);
}
/// <summary>
/// 取消调用指定服务引用的服务实例
/// </summary>
/// <param name="reference">服务引用</param>
/// <returns>是否成功</returns>
public bool UnGetService(IServiceReference reference)
{
if (reference != null && bundleUsingServiceReferenceList.Contains(reference))
{
bundleUsingServiceReferenceList.Remove(reference);
}
return(((IFrameworkService)framework).UnGetService(reference, GetBundle()));
}
public ServiceRegistration(IBundle b, object s, IDictionary props)
{
bundle = b;
service = s;
properties = props;
reference = new ServiceReference(this);
available = true;
}
public static object GetInstance(this IServiceReference svc)
{
if (svc is null)
{
throw new ArgumentNullException(nameof(svc));
}
return(svc.RelatedServiceEntry.GetInstance(svc));
}
public object GetRegisterService(string clazz)
{
IServiceReference reference = GetServiceReference(clazz);
if (reference != null)
{
return(GetRegisterService(reference));
}
return(null);
}
/// <summary>
/// 启动Word应程序管理器
/// </summary>
public void Start()
{
if (!_isActive)
{
string type = "Microsoft.Office.Tools.CustomTaskPaneCollection";
_customTaskPaneReference = _context.GetServiceReference(type);
if (_customTaskPaneReference != null)
{
_isActive = true;
}
}
}
/// <summary>
/// 设置启动级别
/// </summary>
/// <param name="value"></param>
private void SetStartLevel(int value)
{
IServiceReference reference = context.GetServiceReference(typeof(IStartLevel).FullName);
var startService = context.GetService <IStartLevel>(reference);
if (startService == null)
{
return;
}
startService.StartLevel = (value);
context.UngetService(reference);
}
//////////////////////////////////////////////////////////////////////////
// Internals
//////////////////////////////////////////////////////////////////////////
public IServiceReference[] getRegisteredServices()
{
m_checker.Check();
lock (m_lock)
{
IServiceReference[] ret = new IServiceReference[m_publishedServices.Count];
for (int i = 0; i != m_publishedServices.Count; ++i)
{
m_publishedServices[i].getReference();
}
return(ret);
}
}
/// <summary>
/// 获取用户指定的类型的服务
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public T GetService <T>()
{
string clazz = typeof(T).FullName;
IServiceReference reference = context.GetServiceReference(clazz);
if (reference == null)
{
return(default(T));
}
T service = context.GetService <T>(reference);
context.UngetService(reference);
return(service);
}
/// <summary>
/// Returns the effective service instance from the given <paramref name="reference"/>. The <paramref name="reference"/> must be taken from this entry.
/// </summary>
public virtual object GetInstance(IServiceReference reference)
{
if (reference is null)
{
throw new ArgumentNullException(nameof(reference));
}
if (reference.RelatedServiceEntry != this)
{
throw new ArgumentException(Resources.INCOMPATIBLE_REFERENCE);
}
return(reference.Value !);
}
/// <summary>
/// 匹配
/// </summary>
/// <param name="reference">服务引用</param>
/// <returns>bool</returns>
public bool IsAssignableTo(IServiceReference reference)
{
//if (!scopeEvents)
// return true;
string[] clazzes = reference.GetClasses();
for (int i = 0; i < clazzes.Length; i++)
{
if (!reference.IsAssignableTo(bundle, clazzes[i]))
{
return(false);
}
}
return(true);
}
/// <summary>
/// 获取正在使用指定服务的所有Bundle模块
/// </summary>
/// <param name="reference">服务引用</param>
/// <returns>正在使用服务的Bundle列表</returns>
public IList <IBundle> GetUsingBundles(IServiceReference reference)
{
if (usingServiceBundleDict.ContainsKey(reference))
{
IList <IBundle> usingBundleList = usingServiceBundleDict[reference];
var usingBundles = new IBundle[usingBundleList.Count];
usingBundleList.CopyTo(usingBundles, 0);
return(usingBundles);
}
else
{
return(new IBundle[0]);
}
}
/// <summary>
/// Lookups the service references.
/// </summary>
/// <param name="clazz">The clazz.</param>
/// <param name="filter">The filter.</param>
/// <returns>IServiceReference[].</returns>
/// Performs a lookup for ServiceReferences that are bound to this
/// ServiceRegistry. If both clazz and filter are null then all bound
/// ServiceReferences are returned.
/// @param clazz A fully qualified class name. All ServiceReferences that
/// reference an object that implement this class are returned. May be
/// null.
/// @param filter Used to match against published Services. All
/// ServiceReferences that match the filter are returned. If a clazz is
/// specified then all ServiceReferences that match the clazz and the
/// filter parameter are returned. May be null.
/// @return An array of all matching ServiceReferences or null
/// if none exist.
public IServiceReference[] LookupServiceReferences(string clazz, IFilter filter)
{
int size;
List <IServiceReference> references = null;
List <IServiceRegistration> serviceRegs = null;
if (clazz == null) /* all services */
{
serviceRegs = AllPublishedServices;
}
else
{
/* services registered under the class name */
if (PublishedServicesByClass.ContainsKey(clazz))
{
serviceRegs = (List <IServiceRegistration>)PublishedServicesByClass[clazz];
}
}
if (serviceRegs == null)
{
return(null);
}
size = serviceRegs.Count;
if (size == 0)
{
return(null);
}
references = new List <IServiceReference>();
for (int i = 0; i < size; i++)
{
IServiceRegistration registration = (IServiceRegistration)serviceRegs[i];
IServiceReference reference = registration.GetReference();
if ((filter == null) || filter.Match(reference))
{
references.Add(reference);
}
}
if (references.Count == 0)
{
return(null);
}
return((IServiceReference[])references.ToArray());
}
/// <summary>
/// 使用服务的属性进行匹配
/// </summary>
/// <param name="reference"></param>
/// <returns></returns>
public bool Match(IServiceReference reference)
{
try
{
if (reference is ServiceReferenceImpl)
{
return(Match0(((ServiceReferenceImpl)reference).Registration.GetProperties()));
}
return(Match0(new ServiceReferenceDictionary(reference)));
}
catch (Exception e)
{
Log.Debug(e);
return(false);
}
}
/// <summary>
/// 取消注册公开的服务对象
/// </summary>
/// <param name="serviceReference">服务引用</param>
public void UnRegisterService(IServiceReference serviceReference)
{
FireServiceEvent(new ServiceEventArgs(ServiceEventArgs.UNREGISTERING, serviceReference.GetSercieContracts(), serviceReference));
foreach (string contract in serviceReferenceDictionary.Keys)
{
IList <IServiceReference> serviceReferenceList = serviceReferenceDictionary[contract];
if (serviceReferenceList.Contains(serviceReference))
{
serviceReferenceList.Remove(serviceReference);
}
}
if (usingServiceBundleDict.ContainsKey(serviceReference))
{
usingServiceBundleDict.Remove(serviceReference);
}
}
public static DotGraphNode AsDotGraphNode(this IServiceReference serviceReference)
{
string friendlyName = serviceReference.RelatedServiceEntry.FriendlyName();
return(new DotGraphNode
(
friendlyName.GetHashCode
(
#if !NETSTANDARD2_0
System.StringComparison.OrdinalIgnoreCase
#endif
)
)
{
Label = $"<u>{friendlyName}</u><br/><br/><i>{serviceReference.RelatedServiceEntry.Lifetime}</i>"
});
}
public static void SetInstance(this IServiceReference svc)
{
if (svc is null)
{
throw new ArgumentNullException(nameof(svc));
}
//
// Elmeletileg a SetInstance() csak akkor lehet hivva ha szukseges is letrehozni a
// szervizpeldanyt.
//
if (!svc.RelatedServiceEntry.SetInstance(svc))
{
throw new InvalidOperationException(); // TODO: error message
}
}
public void OnRoutineStart(
IServiceReference serviceRef,
IMethodReference methodRef,
PersistedMethodId methodId,
object serviceInstance,
IAsyncStateMachine routineStateMachine,
CallerDescriptor caller)
{
Context.ServiceRef = serviceRef;
Context.MethodRef = methodRef;
Context.MethodId = methodId;
Context.ServiceInstance = serviceInstance;
Context.RoutineStateMachine = routineStateMachine;
Context.Caller = caller;
_intrinsicFlowController.OnRoutineStart(this);
}
/// <summary>
/// 根据服务引用获取对应的服务实例
/// </summary>
/// <param name="reference">服务引用</param>
/// <param name="bundle">调用服务的Bundle</param>
/// <returns>服务实例</returns>
public object GetService(IServiceReference reference, IBundle bundle)
{
ServiceReference sri = reference as ServiceReference;
if (sri == null)
{
return(null);
}
if (!usingServiceBundleDict.ContainsKey(reference))
{
usingServiceBundleDict.Add(reference, new List <IBundle>());
}
usingServiceBundleDict[reference].Add(bundle);
return(sri.GetService());
}
/// <summary>
/// 根据服务引用获取服务对象
/// </summary>
/// <param name="reference"></param>
/// <returns></returns>
public object GetService(IServiceReference reference)
{
CheckValid();
if (reference == null)
{
throw new ArgumentNullException("A null service reference is not allowed."); //$NON-NLS-1$
}
lock (contextLock)
{
if (servicesInUse == null)
{
// Cannot predict how many services a bundle will use, start with a small table.
servicesInUse = new Hashtable();
}
}
return(framework.ServiceRegistry.GetService(this, (ServiceReferenceImpl)reference));
}
/// <summary>
/// 取消注册公开的服务对象
/// </summary>
/// <param name="serviceReference">服务引用</param>
public void UnRegisterService(IServiceReference serviceReference)
{
if (!serviceReferenceList.Contains(serviceReference))
{
return;
}
//触发服变更事件
foreach (var bundleObj in this.framework.GetBundles())
{
var fireContext = (IContextFireEvent)bundleObj.GetBundleContext();
fireContext.FireServiceChanged(this.bundle, new ServiceEventArgs(ServiceEventArgs.UNREGISTERING, serviceReference.GetSercieContracts(), serviceReference));
}
((IFrameworkService)framework).UnRegisterService(serviceReference);
serviceReferenceList.Remove(serviceReference);
}
/// <summary>
/// 启动列表中所有的插件
/// </summary>
/// <param name="bundles"></param>
private void StartBundles(IBundle[] bundles)
{
IServiceReference reference = context.GetServiceReference(typeof(IStartLevel).FullName);
IStartLevel startService = null;
if (reference != null)
{
startService = context.GetService <IStartLevel>(reference);
}
try
{
foreach (AbstractBundle bundle in bundles)
{
if (bundle == null)
{
break;
}
if (bundle.BundleData.Policy == ActivatorPolicy.Lazy)
{
StartBundle(bundle, BundleOptions.Transient);
}
else
{
// always set the startlevel incase it has changed (bug 111549)
// this is a no-op if the level is the same as previous launch.
if (bundle.StartLevel == 0 && startService != null)
{
startService.SetBundleStartLevel(bundle, GetStartLevel());
}
StartBundle(bundle, BundleOptions.General);
}
}
}
finally
{
if (reference != null)
{
context.UngetService(reference);
}
}
}
/// <summary>
/// 解析插件
/// </summary>
/// <param name="bundles"></param>
/// <returns></returns>
private bool ResolvePackages(IBundle[] bundles)
{
IServiceReference packageAdminRef = context.GetServiceReference(typeof(IPackageAdmin).FullName);
PackageAdminImpl packageAdmin = null;
if (packageAdminRef != null)
{
packageAdmin = (PackageAdminImpl)context.GetService(packageAdminRef);
}
if (packageAdmin == null)
{
return(false);
}
// TODO this is such a hack it is silly. There are still cases for race conditions etc
// but this should allow for some progress...
bool isResolved = packageAdmin.ResolveBundles(bundles);
context.UngetService(packageAdminRef);
return(isResolved);
}
/// <summary>
/// 启动Word应程序管理器
/// </summary>
public void Start()
{
if (!isActive)
{
string type = "Microsoft.Office.Interop.Word.Application";
wordApplicationReference = context.GetServiceReference(type);
if (wordApplicationReference != null)
{
OfficeWord.Application app = this.GetApp();
if (app != null)
{
app.DocumentOpen += OnDocumentOpen;
app.DocumentChange += OnDocumentChange;
app.DocumentBeforeSave += OnDocumentBeforeSave;
app.DocumentBeforeClose += OnDocumentBeforeClose;
app.WindowActivate += OnWindowActivate;
app.WindowSelectionChange += OnSelectionChange;
}
isActive = true;
}
}
}
public bool TryResolve(ServiceId serviceId, out IServiceReference serviceReference)
{
IServiceDefinition serviceDefinition;
if (string.Equals(serviceId.Name, IntrinsicCommunicationModel.IntrinsicRoutinesServiceDefinition.Name, StringComparison.OrdinalIgnoreCase))
{
serviceDefinition = IntrinsicCommunicationModel.IntrinsicRoutinesServiceDefinition;
}
else
{
serviceDefinition = _communicationModel.FindServiceByName(serviceId.Name);
// Convenience resolution if a person typed the "Service" suffix where the full service name matches the class name.
if (serviceDefinition == null && serviceId.Name.EndsWith("Service", StringComparison.OrdinalIgnoreCase))
{
var candidateServiceName = serviceId.Name.Substring(0, serviceId.Name.Length - 7);
serviceDefinition = _communicationModel.FindServiceByName(candidateServiceName);
if (serviceDefinition != null && serviceDefinition.Implementation != null &&
serviceDefinition.Implementation.Name.Equals(serviceId.Name, StringComparison.OrdinalIgnoreCase))
{
serviceId = serviceId.Clone();
serviceId.Name = candidateServiceName;
}
else
{
serviceDefinition = null;
}
}
}
if (serviceDefinition == null)
{
serviceReference = null;
return(false);
}
serviceReference = new ServiceReference(_domainServiceProvider, serviceId, serviceDefinition);
return(true);
}
//////////////////////////////////////////////////////////////////////////
public bool ungetService(IServiceReference reference)
{
m_checker.Check();
throw new NotImplementedException();
}
//////////////////////////////////////////////////////////////////////////
// Internals
//////////////////////////////////////////////////////////////////////////
public IServiceReference[] getRegisteredServices()
{
m_checker.Check();
lock (m_lock)
{
IServiceReference[] ret = new IServiceReference[m_publishedServices.Count];
for (int i = 0; i != m_publishedServices.Count; ++i)
m_publishedServices[i].getReference();
return ret;
}
}
public bool Match(IServiceReference reference)
{
return true;
}
//////////////////////////////////////////////////////////////////////////
public int CompareTo(IServiceReference other)
{
throw new NotImplementedException();
}
/// <summary>
/// Creates a new service event object.
/// </summary>
public ServiceEvent(ServiceEvent.Type type, IServiceReference reference)
{
m_type = type;
m_reference = reference;
}
public ServiceEventArgs(ServiceState state, IServiceReference reference)
{
this.reference = reference;
this.state = state;
}
