public static void LoadPlugins()
{
string[] PluginFiles = Directory.GetFiles(Program.PluginPath);
foreach (string file in PluginFiles)
{
//判断文件格式是否为.dll格式
if (Path.GetExtension(file).ToLower() == ".dll" && Plugins.Find(ab => ab.FullPath == file) == null)
{
PluginDomain pluginDomain = file.GetPluginObject(PluginTypes);
if (pluginDomain != null && pluginDomain.isSuccess)
{
PluginItem Pinfo = new PluginItem {
FullPath = file
};
Pinfo.PluginVersion = pluginDomain.GetPropertyValue <Version>("PluginVersion");
if (Pinfo.PluginVersion != null)
{
Pinfo.PluginName = pluginDomain.GetPropertyValue <string>("PluginName");
Pinfo.Domain = pluginDomain;
Plugins.Add(Pinfo);
System.Diagnostics.Debug.WriteLine("加载插件：" + Pinfo.PluginName + " | 版本：" + Pinfo.PluginVersion.ToString());
}
else
{
//不匹配卸载
pluginDomain.Dispose();
}
}
}
}
}
public void Dispose()
{
if (Domain != null)
{
Domain.Dispose();
Domain = null;
}
}
/// <summary>
/// 增加模块域
/// </summary>
/// <param name="moduleDomain"></param>
public void AddModulDomain(PluginDomain pluginDomain)
{
if (this.PluginDomainCollection.IsInstalled(pluginDomain.ModuleDomainName))
{
throw new InvalidDataException(string.Format("已经存在一个相同的{0}插件域", pluginDomain.PluginDomainName));
}
this.PluginDomainCollection.Add(pluginDomain);
}
internal Proxy(PluginDomain domain, params object[] args)
{
if (domain == null)
{
throw new ArgumentNullException("domain");
}
_domain = domain;
_target = (T)((AppDomain)domain).CreateInstanceAndUnwrap(typeof(T).Assembly.FullName, typeof(T).FullName, false, BindingFlags.CreateInstance, null, args, null, null);
}
private void CreatePluginDomain(string pluginDomainName, string pluginDirectory)
{
_domain = new PluginDomain(pluginDomainName, pluginDirectory);
var files = GetPluginFiles(pluginDirectory);
_pluginModifiedDateDictionary.Clear();
foreach (var file in files)
{
_pluginModifiedDateDictionary[file] = File.GetLastWriteTime(file);
}
}
public void TestIEnumerableByRef()
{
#if USE_APPDOMAINS
Console.WriteLine("STARTING");
PluginDomain pd = new PluginDomain("testdomain");
IEnumerable <string> x = new CancellableEnumerable <string>(new CancellationTokenSource(), new[] { "this", "is", "cool" });
pd.InvokeFunc(z => {
Debug.WriteLine(string.Format("APPDOMAIN NAME :{0}", AppDomain.CurrentDomain.FriendlyName));
foreach (var n in z)
{
Debug.WriteLine(string.Format("Item :{0}", n));
}
return("");
}, x);
IEnumerable <Item> items = new CancellableEnumerable <Item>(new CancellationTokenSource(), new[] { new Item {
A = "this"
}, new Item {
A = "aint"
}, new Item {
A = "nice"
} });
var r = pd.InvokeFunc(z => {
Debug.WriteLine(string.Format("APPDOMAIN NAME :{0}", AppDomain.CurrentDomain.FriendlyName));
foreach (var n in z)
{
Debug.WriteLine(string.Format("Item :{0}", n.B));
}
IEnumerable <Item> others = new[] { new Item {
A = "slop"
}, new Item {
A = "goop"
}, new Item {
A = "chop"
} };
return(others);
}, items);
foreach (var n in r)
{
Debug.WriteLine(string.Format("Item :{0}", n.B));
}
#endif
}
internal AutoUpdater(PluginDomain domain)
{
Domain = domain;
string tmpName = Guid.NewGuid().ToString().Replace("-", "");
_tmpDir = Path.Combine(Bridge.TempPath, tmpName);
Directory.CreateDirectory(_tmpDir);
_tmpZip = Path.Combine(Bridge.TempPath, tmpName + ".zip");
_changelog = domain.UpdatingData.Changelog;
_lock = new ManualResetEvent(false);
_client = new WebClient();
_client.DownloadProgressChanged += DownloadProgress;
_client.DownloadFileCompleted += DownloadCompleted;
_progress = new ProgressBar(100);
}
/// <summary>
/// PROTOTYPE - assembly/provider loader.
/// </summary>
/// <param name="primaryAssemblyPath"></param>
/// <returns></returns>
private PluginDomain CreatePluginDomain(string primaryAssemblyPath)
{
try {
// this needs to load the assembly in it's own domain
// so that we can drop them when necessary.
var name = Path.GetFileNameWithoutExtension(primaryAssemblyPath) ?? primaryAssemblyPath;
var pd = new PluginDomain(string.Format(CultureInfo.CurrentCulture, "PluginDomain [{0}]", name.Substring(name.LastIndexOf('.') + 1)));
// inject this assembly into the target appdomain.
pd.LoadFileWithReferences(Assembly.GetExecutingAssembly().Location);
return(pd);
} catch (Exception e) {
e.Dump();
}
return(null);
}
/// <summary>
/// Finishes the process and unlocks the main thread.
/// </summary>
private void Finish()
{
string pluginPath = Path.Combine(Bridge.PluginsPath, Domain.UpdatingData.PluginFile + ".dll");
Domain = new PluginDomain(Domain.PluginManager, pluginPath);
Domain.Initialize();
if (Domain.Plugin.State == PluginState.Failed)
{
Domain = null;
return;
}
_progress.Refresh(100, "Finished!");
Domain.Plugin.Logger.Info("Update v{VER} successfully installed! {CHANGELOG}", Domain.Plugin.Meta.Version,
(string.IsNullOrEmpty(_changelog) ? "" : _changelog));
_lock.Set();
}
private void UnloadAssembly(Assembly assembly)
{
PluginDomain pd = null;
try {
lock (_domains) {
pd = _domains[assembly];
_domains.Remove(assembly);
}
} catch (Exception e) {
e.Dump();
}
if (pd != null)
{
((IDisposable)pd).Dispose();
}
pd = null;
}
/// <summary>
/// Handles the incoming calling from the native side.
/// </summary>
private static object HandleCalling(string key, object[] args)
{
try
{
if (key == "call-event")
{
int typeId = System.Convert.ToInt32(args[0]);
if (typeId == 7 || typeId == 6)
{
return(true);
}
EventType type = (EventType)typeId;
bool flag = true;
PluginManager.IteratePlugins(plugin =>
{
if (plugin == null || plugin.State == PluginState.Failed)
{
return;
}
PluginDomain domain = PluginManager.GetDomain(plugin);
if (domain == null)
{
Logger.Fatal("Could not get plugin domain for loaded plugin {PLUGIN}!", plugin.Display);
return;
}
object[] objArgs = ParseEventArgs(domain, type, args);
if (!domain.Server.CallEvent(type, objArgs))
{
flag = false;
}
if (type == EventType.PlayerQuit)
{
domain.Server.PlayerPool.RemoveEntity((Player)objArgs[0]);
}
else if (type == EventType.PlayerSteamAuth)
{
Player player = (Player)objArgs[0];
lock (Admins)
{
player.IsAdmin = Admins.Contains(player.SteamID);
}
}
else if (type == EventType.ConsoleInput)
{
ConsoleManager.PollInput((string)objArgs[0]);
}
});
return(flag);
}
if (key == "call-remote")
{
int player = System.Convert.ToInt32(args[0]);
string pluginId = (string)args[1];
string name = (string)args[2];
object[] remoteArgs = new object[args.Length - 3];
for (int i = 3; i < args.Length; i++)
{
remoteArgs[i - 3] = args[i];
}
Plugin plugin = PluginManager.GetPlugin(pluginId);
if (plugin != null)
{
PluginManager.GetDomain(plugin)?.Server.FireRemoteEvent(name, player, remoteArgs);
}
return(null);
}
if (key == "call-command")
{
string pluginId = (string)args[0];
int player = System.Convert.ToInt32(args[1]);
string name = (string)args[2];
string line = (string)args[3];
if (pluginId == "native")
{
return(null);
}
Plugin plugin = PluginManager.GetPlugin(pluginId);
if (plugin != null)
{
PluginManager.GetDomain(plugin)?.Server.FireCommand(player, name, line);
}
return(null);
}
if (key == "call-timer")
{
string id = (string)args[0];
Timer.CallTimer(id);
return(null);
}
if (key == "call-delay")
{
string id = (string)args[0];
Timer.CallDelay(id);
return(null);
}
if (key == "interop")
{
string pluginId = (string)args[0];
string funcName = (string)args[1];
object[] @params = new object[args.Length - 2];
for (int i = 2; i < args.Length; i++)
{
@params[i - 2] = args[i];
}
Plugin plugin = PluginManager.GetPlugin(pluginId);
return(plugin != null?PluginManager.GetDomain(plugin)?.Server.FireExportable(funcName, @params) : null);
}
}
catch (Exception ex)
{
Logger.Error(ex,
"An error occurred while handling a call {CALLNAME} from the native side! The data which was excepted is the following when debug enabled!",
key);
Logger.Debug("Data for the Call:\n{DATA}", Json.ToJson(args, Json.Flag.Pretty));
}
return(null);
}
