/// <inheritdoc />
protected override DependencyObject GetContainerForItemOverride()
{
ProxyGenerator proxyGen = new ProxyGenerator();
var containerForItemOverride = new MyRibbonTab();
if (EnableProxy)
{
var interceptor = new BaseInterceptorImpl(UseLogMethod, ProxyGeneratorHelper.ProxyGenerator);
interceptor.Callback = ProxyCallback;
var tabPRoxy = proxyGen.CreateClassProxyWithTarget(containerForItemOverride,
new ProxyGenerationOptions(new MyRibbonGenHook()),
interceptor);
return(tabPRoxy);
}
return(containerForItemOverride);
}
T IProxyBuilderOptionsContext <T> .Build()
{
T result = null;
var options = CreateOptions();
if (_proxyType == ProxyTypes.Interface)
{
if (options != null)
{
result = _target != null?
ProxyGenerator.CreateInterfaceProxyWithTarget <T>(_target, options, _interceptors.ToArray()) :
_targetInterface != null?
ProxyGenerator.CreateInterfaceProxyWithTargetInterface <T>(_target, options, _interceptors.ToArray()) :
ProxyGenerator.CreateInterfaceProxyWithoutTarget <T>(options, _interceptors.ToArray());
}
else
{
result = _target != null?
ProxyGenerator.CreateInterfaceProxyWithTarget <T>(_target, _interceptors.ToArray()) :
_targetInterface != null?
ProxyGenerator.CreateInterfaceProxyWithTargetInterface <T>(_target, _interceptors.ToArray()) :
ProxyGenerator.CreateInterfaceProxyWithoutTarget <T>(_interceptors.ToArray());
}
}
if (_proxyType == ProxyTypes.Class)
{
if (options != null)
{
result = _target != null?
ProxyGenerator.CreateClassProxyWithTarget <T>(_target, options, _interceptors.ToArray()) :
ProxyGenerator.CreateClassProxy <T>(options, _interceptors.ToArray());
}
else
{
result = _target != null?
ProxyGenerator.CreateClassProxyWithTarget <T>(_target, _interceptors.ToArray()) :
ProxyGenerator.CreateClassProxy <T>(_interceptors.ToArray());
}
}
return(result);
}
public static object AsTrackable(this object obj)
{
//is the object already a trackable object?
if (obj is ITrackableObject)
{
return(obj);
}
ObjectTrackingState objectTrackingState = new ObjectTrackingState(obj);
object result = Generator.CreateClassProxyWithTarget(
obj.GetType(),
new[] { typeof(ITrackableObject), typeof(INotifyPropertyChanging), typeof(INotifyPropertyChanged) },
obj,
new PropertyChangingInterceptor(objectTrackingState),
new PropertyChangedInterceptor(objectTrackingState),
new ObjectInterceptor(objectTrackingState)
);
return(result);
}
/// <summary>
/// Enables automatic saving when changing any <b>virtual properties</b>.
/// </summary>
/// <typeparam name="TSettings">A settings class implementing <see cref="JsonSettings"/></typeparam>
/// <param name="settings">The settings class to wrap in a proxy.</param>
/// <returns></returns>
public static TSettings EnableAutosave <TSettings>(this TSettings settings) where TSettings : JsonSettings
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
//if it doesn't contain any virtual methods, notify developer about it.
if (!settings.GetType().GetProperties().Where(p => _jsonSettingsAbstractionVirtuals.All(av => !p.Name.Equals(av))).Any(p => p.GetGetMethod().IsVirtual))
{
var msg = $"JsonSettings: During proxy creation of {settings.GetType().Name}, no virtual properties were found which will make Autosaving redundant.";
Debug.WriteLine(msg);
if (Debugger.IsAttached)
{
Console.Error.WriteLine(msg);
}
return(settings);
}
_generator = _generator ?? new ProxyGenerator();
return(_generator.CreateClassProxyWithTarget <TSettings>(settings, new JsonSettingsInterceptor((nucs.JsonSettings.JsonSettings)(object) settings)));
}
public void DynamicProxy_NonIntercepted_Property_Leaked()
{
var instance = new TestClassForCache();
var toProxy = instance.GetType();
var proxyGenerationOptions = new ProxyGenerationOptions(
new TestCacheProxyGenerationHook()
);
var generator = new ProxyGenerator();
var proxy = generator.CreateClassProxyWithTarget(
toProxy,
instance,
proxyGenerationOptions
);
var accessor = (ITestCacheInterface)proxy;
accessor.InstanceProperty = 1;
Assert.AreEqual(accessor.InstanceProperty, instance.InstanceProperty);
}
/// <summary>
/// Decoration request
/// </summary>
/// <param name="context">Context info</param>
/// <remarks>do not have to decorate, but may if it wants to. sorta..</remarks>
public void Decorate(DecoratorContext context)
{
if (!CanDecorate(context))
{
return;
}
var options = new ProxyGenerationOptions();
var services = context.Services;
if (IgnoreClassAsService && services.Length > 1)
{
services = services.Where(x => !x.IsClass).ToArray();
}
var generator = new ProxyGenerator();
if (services.Any(x => x.IsClass))
{
if (services.Length > 1)
{
throw new InvalidOperationException(
"A class that register itself as a service may not also be registered with interfaces. See the remarks in the IgnoreClassAsService property.");
}
var clazz = context.Services.Single(x => x.IsClass);
context.Instance = generator.CreateClassProxyWithTarget(clazz, context.Instance,
CreateInterceptor(context));
}
else
{
var others = services.Where(x => x.IsInterface).Skip(1);
var first = services.First();
context.Instance = generator.CreateInterfaceProxyWithTarget
(first, others.ToArray(), context.Instance,
CreateInterceptor(context));
}
}
/// <summary>
/// Creates a proxy for the given object based on the type specified.
///
/// If the type given is:
/// - a class, then a class proxy is used
/// - an interface, then an interface proxy is used
///
/// Will assign IDecorator.Self=proxy on |obj| if possible.
/// </summary>
/// <param name="type">The proxy type to create.</param>
/// <param name="obj">The object to decorate. Can be null.</param>
/// <returns>A decorator proxy of the requested type, or null if |obj| is null.</returns>
/// <exception cref="ArgumentException">
/// Thrown if unable to decorate |obj| for any reason. Some examples include:
/// - type is not a class or interface
/// - |type| is not assignable from obj.GetType()
/// </exception>
public object Decorate(Type type, object obj)
{
if (obj == null)
{
return(obj);
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (!type.IsAssignableFrom(obj.GetType()))
{
throw new ArgumentException("Decorate should only be used on " +
$"classes or interfaces. It was called on type '{type.FullName}'.");
}
object proxy = null;
if (type.IsClass)
{
proxy = proxyGenerator.CreateClassProxyWithTarget(type, obj, options, aspects);
}
else if (type.IsInterface)
{
proxy = proxyGenerator.CreateInterfaceProxyWithTarget(
type, obj, options, aspects);
}
else
{
throw new ArgumentException("Decorate should only be used on " +
$"classes or interfaces. It was called on type '{type.FullName}'.");
}
DecoratorSelfUtil.TrySetSelf(obj, proxy);
return(proxy);
}
public TProxy GenerateProxyFrom <TProxy>(TProxy target) where TProxy : class, IChangeTrackable
{
return(_proxy.CreateClassProxyWithTarget(target, new ChangeTrackingInterceptor()));
}
public void Select_Interceptors_For_Methods_For_ClassProxy_With_Target()
{
var generator = new ProxyGenerator();
var options = new ProxyGeneratorOptions();
options.InterceptorSelector = new IS1();
var target = new TypeIS1();
var proxy = generator.CreateClassProxyWithTarget <TypeIS1>(target, options, new IntGetForIS1(), new IntSetForIS1(), new IntMethForIS1(), new IntAddForIS1(), new IntRemoveForIS1());
Assert.AreEqual(false, IntGetForIS1.IsCalled);
Assert.AreEqual(false, IntSetForIS1.IsCalled);
Assert.AreEqual(false, IntMethForIS1.IsCalled);
Assert.AreEqual(0, TypeIS1.States.Count);
// set
proxy.MyProperty = "New value";
Assert.AreEqual(false, IntGetForIS1.IsCalled);
Assert.AreEqual(true, IntSetForIS1.IsCalled);
Assert.AreEqual(false, IntMethForIS1.IsCalled);
Assert.AreEqual(false, IntAddForIS1.IsCalled);
Assert.AreEqual(false, IntRemoveForIS1.IsCalled);
Assert.AreEqual(1, TypeIS1.States.Count);
Assert.AreEqual(StateTypes.Set_Called, TypeIS1.States[0]);
IntSetForIS1.IsCalled = false;
IntGetForIS1.IsCalled = false;
IntMethForIS1.IsCalled = false;
IntAddForIS1.IsCalled = false;
IntRemoveForIS1.IsCalled = false;
TypeIS1.States.Clear();
// get
var p = proxy.MyProperty;
Assert.AreEqual(true, IntGetForIS1.IsCalled);
Assert.AreEqual(false, IntSetForIS1.IsCalled);
Assert.AreEqual(false, IntMethForIS1.IsCalled);
Assert.AreEqual(false, IntAddForIS1.IsCalled);
Assert.AreEqual(false, IntRemoveForIS1.IsCalled);
Assert.AreEqual("New value", p);
Assert.AreEqual(1, TypeIS1.States.Count);
Assert.AreEqual(StateTypes.Get_Called, TypeIS1.States[0]);
IntSetForIS1.IsCalled = false;
IntGetForIS1.IsCalled = false;
IntMethForIS1.IsCalled = false;
IntAddForIS1.IsCalled = false;
IntRemoveForIS1.IsCalled = false;
TypeIS1.States.Clear();
// method
proxy.Method();
Assert.AreEqual(false, IntGetForIS1.IsCalled);
Assert.AreEqual(false, IntSetForIS1.IsCalled);
Assert.AreEqual(true, IntMethForIS1.IsCalled);
Assert.AreEqual(false, IntAddForIS1.IsCalled);
Assert.AreEqual(false, IntRemoveForIS1.IsCalled);
Assert.AreEqual(1, TypeIS1.States.Count);
Assert.AreEqual(StateTypes.Class_Method, TypeIS1.States[0]);
IntSetForIS1.IsCalled = false;
IntGetForIS1.IsCalled = false;
IntMethForIS1.IsCalled = false;
IntAddForIS1.IsCalled = false;
IntRemoveForIS1.IsCalled = false;
TypeIS1.States.Clear();
// method with parameter
proxy.Method("My paramete");
Assert.AreEqual(false, IntGetForIS1.IsCalled);
Assert.AreEqual(false, IntSetForIS1.IsCalled);
Assert.AreEqual(true, IntMethForIS1.IsCalled);
Assert.AreEqual(false, IntAddForIS1.IsCalled);
Assert.AreEqual(false, IntRemoveForIS1.IsCalled);
Assert.AreEqual(1, TypeIS1.States.Count);
Assert.AreEqual(StateTypes.Class_Method_2, TypeIS1.States[0]);
IntSetForIS1.IsCalled = false;
IntGetForIS1.IsCalled = false;
IntMethForIS1.IsCalled = false;
IntAddForIS1.IsCalled = false;
IntRemoveForIS1.IsCalled = false;
TypeIS1.States.Clear();
EventHandler ev = null;
ev = (s, e) => { };
proxy.MyEvent += ev;
Assert.AreEqual(false, IntGetForIS1.IsCalled);
Assert.AreEqual(false, IntSetForIS1.IsCalled);
Assert.AreEqual(false, IntMethForIS1.IsCalled);
Assert.AreEqual(true, IntAddForIS1.IsCalled);
Assert.AreEqual(false, IntRemoveForIS1.IsCalled);
Assert.AreEqual(1, TypeIS1.States.Count);
Assert.AreEqual(StateTypes.AddEvent_IsCalled, TypeIS1.States[0]);
IntSetForIS1.IsCalled = false;
IntGetForIS1.IsCalled = false;
IntMethForIS1.IsCalled = false;
IntAddForIS1.IsCalled = false;
IntRemoveForIS1.IsCalled = false;
TypeIS1.States.Clear();
proxy.MyEvent -= ev;
Assert.AreEqual(false, IntGetForIS1.IsCalled);
Assert.AreEqual(false, IntSetForIS1.IsCalled);
Assert.AreEqual(false, IntMethForIS1.IsCalled);
Assert.AreEqual(false, IntAddForIS1.IsCalled);
Assert.AreEqual(true, IntRemoveForIS1.IsCalled);
Assert.AreEqual(1, TypeIS1.States.Count);
Assert.AreEqual(StateTypes.RemoveEvent_IsCalled, TypeIS1.States[0]);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TClass"></typeparam>
/// <param name="class"></param>
/// <param name="interceptors"></param>
/// <returns></returns>
public static TClass GenerateClassProxy <TClass>(this TClass @class, params IInterceptor[] interceptors) where TClass : class
{
var proxyGenerator = new ProxyGenerator();
return(proxyGenerator.CreateClassProxyWithTarget(@class, interceptors));
}
/// <summary>
/// Gets the class proxy.
/// </summary>
/// <typeparam name="TClass">The type of the class.</typeparam>
/// <param name="target">The target.</param>
/// <param name="proxyGenerationHook">The proxy generation hook.</param>
/// <param name="interceptors">The interceptors.</param>
/// <returns>
/// A proxy from the class with the type <see cref="TClass"/>.
/// </returns>
public static TClass GetClassProxy <TClass>(TClass target, IProxyGenerationHook proxyGenerationHook, params IInterceptor[] interceptors) where TClass : class
{
return((TClass)proxyGenerator.CreateClassProxyWithTarget(typeof(TClass), target, new ProxyGenerationOptions(proxyGenerationHook), interceptors));
}
public T MakeObject()
{
return(ProxyGenerator.CreateClassProxyWithTarget <T>(_object, new ClassInterceptor()));
}
public static object NeverNull(object source, Type type)
{
return(_generator.CreateClassProxyWithTarget(type, new[] { typeof(IUnBoxProxy) }, source,
new NeverNullInterceptor(source)));
}
public TService CreateClassProxy <TService>(TService implementationInstance, IInterceptronInterceptor[] interceptors) where TService : class
{
return(generator.CreateClassProxyWithTarget(implementationInstance, DynamicProxyGeneratorHelper.ToDynamicProxyInterceptors(interceptors)));
}
/// <summary>Intercepts the specified invocation.</summary>
/// <param name="invocation">The invocation.</param>
/// <autogeneratedoc />
/// TODO Edit XML Comment Template for Intercept
public override void Intercept(IInvocation invocation)
{
Interlocked.Increment(ref _callDepth);
var x = _stack.Any( ) ? _stack.Peek( ) : null;
var myX = new StackInfo( );
_stack.Push(myX);
var writeLine = WriteLine;
if (x != null)
{
x.Written = true;
writeLine("");
}
var formatted = FormatInvocation(invocation, "");
var a = new InvocationEventArgs {
Formatted = formatted
};
DumpInvocation(invocation, _callDepth);
invocation.Proceed( );
try
{
DumpReturnValue(invocation, _callDepth, !myX.Written);
if (ProxyGenerator != null &&
invocation.ReturnValue != null &&
!invocation.ReturnValue.GetType( ).IsSealed &&
!(invocation.ReturnValue is IProxyTargetAccessor))
{
var r = invocation.ReturnValue;
if (r is XamlType typ)
{
var invoker =
( XamlTypeInvoker )ProxyGenerator.CreateClassProxyWithTarget(
typeof(
XamlTypeInvoker
)
, typ
.Invoker
, new[]
{
r
}
, this
);
object[] args = { typ.UnderlyingType, typ.SchemaContext, invoker };
invocation.ReturnValue =
ProxyGenerator.CreateClassProxyWithTarget(
r.GetType( )
, r
, args
, this
);
}
else if (r.GetType( ).IsGenericType &&
r.GetType( ).GetGenericTypeDefinition( )
== typeof(XamlValueConverter <object>)
.GetGenericTypeDefinition( ))
{
object[] args = null;
switch (r)
{
case XamlValueConverter <ValueSerializer> q: args = new object[] { q.ConverterType, q.TargetType, q.Name };
break;
case XamlValueConverter <TypeConverter> z: args = new object[] { z.ConverterType, z.TargetType, z.Name };
break;
}
if (args != null)
{
invocation.ReturnValue =
ProxyGenerator.CreateClassProxyWithTarget(
r.GetType( )
, r
, args
, this
);
}
}
else if (r.GetType( ).IsGenericType &&
r.GetType( ).GetGenericTypeDefinition( )
== typeof(ReadOnlyCollection <object>)
.GetGenericTypeDefinition( ))
{
var propInfo = r.GetType( )
.GetField(
"list"
, BindingFlags.NonPublic | BindingFlags.Instance
);
if (propInfo != null)
{
var args = new[] { propInfo.GetValue(r) };
invocation.ReturnValue =
ProxyGenerator.CreateClassProxyWithTarget(
r.GetType( )
, r
, args
, this
);
}
}
else
{
switch (r)
{
case XamlDirective d:
{
object[] args =
{
d.GetXamlNamespaces( ), d.Name, d.Type, d.TypeConverter
, d.AllowedLocation
};
invocation.ReturnValue =
ProxyGenerator.CreateClassProxyWithTarget(
r.GetType( )
, r
, args
, this
);
break;
}
case NamespaceDeclaration ns:
invocation.ReturnValue =
ProxyGenerator.CreateClassProxyWithTarget(
r.GetType( )
, r
, new object[]
{
ns.Namespace, ns.Prefix
}
, this
);
break;
default:
try
{
invocation.ReturnValue =
ProxyGenerator.CreateClassProxyWithTarget(
r.GetType( )
, r
, this
);
}
catch (InvalidProxyConstructorArgumentsException)
{
writeLine("Constructors for ⮜" + FormatTyp(r.GetType( )) + "⮞");
foreach (var constructorInfo in r.GetType( ).GetConstructors( ))
{
writeLine(
FormatTyp(constructorInfo.DeclaringType)
+ " ( "
+ string.Join(
" , "
, constructorInfo
.GetParameters( )
.Select(
(info, i)
=> FormatTyp(
info
.ParameterType
)
+ " "
+ info.Name
+ (info.HasDefaultValue
? " = "
+ info
.DefaultValue
: "")
)
)
);
}
}
break;
}
}
}
}
catch (Exception ex)
{
writeLine("--Exception--");
writeLine(ex.ToString( )); //.GetType ( ) ) ;
//Console.WriteLine ( ex.Message ) ;
writeLine("--End Exception--");
}
finally
{
_stack.Pop( );
Interlocked.Decrement(ref _callDepth);
}
}
public static T create()
{
return((T)generator.CreateClassProxyWithTarget(typeof(T), new T(), new Interceptor()));
}
protected override TProxy InvokeCastleProxyGenerator <TProxy>(ProxyGenerator proxyGenerator, TProxy target, IInterceptor interceptor)
{
return(proxyGenerator.CreateClassProxyWithTarget <TProxy>(target, interceptor));
}
protected internal virtual object InstrumentClient(Type clientType, object client, IEnumerable <IInterceptor> preInterceptors)
{
if (client is IProxyTargetAccessor)
{
// Already instrumented
return(client);
}
lock (s_clientValidation)
{
if (!s_clientValidation.TryGetValue(clientType, out var validationException))
{
foreach (MethodInfo methodInfo in clientType.GetMethods(BindingFlags.Instance | BindingFlags.Public))
{
if (methodInfo.Name.EndsWith("Async") && !methodInfo.IsVirtual)
{
validationException = new InvalidOperationException($"Client type contains public non-virtual async method {methodInfo.Name}");
break;
}
if (methodInfo.Name.EndsWith("Client") &&
methodInfo.Name.StartsWith("Get") &&
!methodInfo.IsVirtual)
{
validationException = new InvalidOperationException($"Client type contains public non-virtual Get*Client method {methodInfo.Name}");
break;
}
}
s_clientValidation[clientType] = validationException;
}
if (validationException != null)
{
throw validationException;
}
}
List <IInterceptor> interceptors = new List <IInterceptor>();
if (preInterceptors != null)
{
interceptors.AddRange(preInterceptors);
}
interceptors.Add(new GetOriginalInterceptor(client));
if (TestDiagnostics)
{
interceptors.Add(s_diagnosticScopeValidatingInterceptor);
}
interceptors.Add(new InstrumentResultInterceptor(this));
// Ignore the async method interceptor entirely if we're running a
// a SyncOnly test
TestContext.TestAdapter test = TestContext.CurrentContext.Test;
bool?isSyncOnly = (bool?)test.Properties.Get(ClientTestFixtureAttribute.SyncOnlyKey);
if (isSyncOnly != true)
{
interceptors.Add(IsAsync ? s_avoidSyncInterceptor : s_useSyncInterceptor);
}
return(ProxyGenerator.CreateClassProxyWithTarget(
clientType,
new[] { typeof(IInstrumented) },
client,
interceptors.ToArray()));
}
static int DoInstall(string game, string filename, string installationPath, string profilePath, string gamePath,
List <string> additionalSearchPaths, string seVersion, ref string errorString)
{
if (game == null)
{
errorString = "no game specified";
return(1);
}
if (filename == null)
{
errorString = "no file specified";
return(1);
}
if (profilePath == null)
{
errorString = "no profile path specified";
return(1);
}
if (gamePath == null)
{
errorString = "no game path specified";
return(1);
}
try
{
EnvironmentInfo environmentInfo = new EnvironmentInfo(Properties.Settings.Default);
string exeLocation = Assembly.GetExecutingAssembly().Location;
string exePath = System.IO.Path.GetDirectoryName(exeLocation);
string[] gameModes = Directory.GetFiles(Path.Combine(exePath, "GameModes"), String.Format("{0}.dll", game));
if (gameModes.Count() == 0)
{
errorString = "unknown game";
return(1);
}
Assembly gameAssembly = Assembly.LoadFrom(gameModes[0]);
IGameModeFactory gameModeFactory = null;
Type[] exportedTypes = gameAssembly.GetExportedTypes();
foreach (Type type in exportedTypes)
{
if (typeof(IGameModeFactory).IsAssignableFrom(type) && !type.IsAbstract)
{
ConstructorInfo constructor = type.GetConstructor(new Type[] { typeof(EnvironmentInfo) });
gameModeFactory = (IGameModeFactory)constructor.Invoke(new Object[] { environmentInfo });
}
}
if (gameModeFactory == null)
{
errorString = "invalid game";
return(1);
}
string str7zPath = Path.Combine(environmentInfo.ProgrammeInfoDirectory, environmentInfo.Is64BitProcess ? "7z-64bit.dll" : "7z-32bit.dll");
SevenZipCompressor.SetLibraryPath(str7zPath);
FileUtil fileUtil = new NexusFileUtil(environmentInfo);
environmentInfo.Settings.InstallationPaths[gameModeFactory.GameModeDescriptor.ModeId] = installationPath;
environmentInfo.Settings.ModFolder[gameModeFactory.GameModeDescriptor.ModeId] = installationPath;
environmentInfo.Settings.InstallInfoFolder[gameModeFactory.GameModeDescriptor.ModeId] = environmentInfo.TemporaryPath;
if (environmentInfo.Settings.DelayedSettings[gameModeFactory.GameModeDescriptor.ModeId] == null)
{
environmentInfo.Settings.DelayedSettings[gameModeFactory.GameModeDescriptor.ModeId] = new KeyedSettings <string>();
}
if (environmentInfo.Settings.DelayedSettings["ALL"] == null)
{
environmentInfo.Settings.DelayedSettings["ALL"] = new KeyedSettings <string>();
}
ViewMessage warning = null;
IGameMode gameMode = gameModeFactory.BuildGameMode(fileUtil, out warning);
// use a proxy so we can intercept accesses to the IGameMode interface. This allows us to make the additional search paths accessible from
// the sandbox and feed in the script extender version even though the nmm lib won't find it.
// This is a massive hack and there is an issue: nmm tries to look up the location of the assembly (for whatever reason) and the proxy
// generated here is in a dynamic assembly and thus doesn't have a location. We will therefore feed the proxy only to the script executor
// and hope for the best
ProxyGenerator generator = new ProxyGenerator();
GameModeInterceptor interceptor = new GameModeInterceptor(additionalSearchPaths, seVersion != null ? new Version(seVersion) : null);
IGameMode gameModeProxied = (IGameMode)generator.CreateClassProxyWithTarget(gameMode.GetType(),
gameMode,
new object[] { environmentInfo, fileUtil },
new IInterceptor[] { interceptor });
IModCacheManager cacheManager = new NexusModCacheManager(environmentInfo.TemporaryPath, gameMode.GameModeEnvironmentInfo.ModDirectory, fileUtil);
IScriptTypeRegistry scriptTypeRegistry = ScriptTypeRegistry.DiscoverScriptTypes(Path.Combine(Path.GetDirectoryName(exeLocation), "ScriptTypes"), gameMode);
if (scriptTypeRegistry.Types.Count == 0)
{
errorString = "No script types were found.";
return(2);
}
IModFormatRegistry formatRegistry = ModFormatRegistry.DiscoverFormats(cacheManager, scriptTypeRegistry, Path.Combine(Path.GetDirectoryName(exeLocation), "ModFormats"));
if (formatRegistry.Formats.Count == 0)
{
errorString = "No formats were found.";
return(2);
}
// we install the mod from the temporary path. Unfortunately this requires the archive to be copied, otherwise the sandbox will
// prevent the installer script from accessing the archive in its original location
string fileNameTemporary = Path.Combine(environmentInfo.TemporaryPath, Path.GetFileName(filename));
File.Copy(filename, fileNameTemporary);
IMod mod = CreateMod(fileNameTemporary, formatRegistry, gameMode);
if (mod == null)
{
errorString = "failed to initialize mod";
return(3);
}
System.IO.File.WriteAllText(installationPath + "/__installInfo.txt", mod.ModName + "\n" + mod.HumanReadableVersion + "\n" + mod.Id);
if (mod.HasInstallScript)
{
DummyDataFileUtilFactory dummyFactory = null;
IDataFileUtil dataFileUtility;
Logger.Info("Detected C# script that relies on files in the actual data folder");
string modlistFile = Path.Combine(profilePath, "modlist.txt");
// ASSUMED mods path is the parent directory of the gameMode.InstallationPath
string modsPath = Directory.GetParent(gameMode.InstallationPath).FullName;
// Prepare dummy data directory
dummyFactory = new DummyDataFileUtilFactory(gameMode.GameModeEnvironmentInfo.InstallationPath, modlistFile, modsPath, gamePath, additionalSearchPaths);
dataFileUtility = dummyFactory.CreateDummyDataFileUtil();
TxFileManager fileManager = new TxFileManager();
IInstallLog installLog = new DummyInstallLog();
IIniInstaller iniIniInstaller = new IniInstaller(mod, installLog, fileManager, delegate { return(OverwriteResult.No); });
IPluginManager pluginManager = new DummyPluginManager(Path.Combine(profilePath, "plugins.txt"), gameMode, mod);
IGameSpecificValueInstaller gameSpecificValueInstaller = gameMode.GetGameSpecificValueInstaller(mod, installLog, fileManager, new NexusFileUtil(environmentInfo), delegate { return(OverwriteResult.No); });
IModFileInstaller fileInstaller = new ModFileInstaller(gameMode.GameModeEnvironmentInfo, mod, installLog, pluginManager, dataFileUtility, fileManager, delegate { return(OverwriteResult.No); }, false);
InstallerGroup installers = new InstallerGroup(dataFileUtility, fileInstaller, iniIniInstaller, gameSpecificValueInstaller, pluginManager);
IScriptExecutor executor = mod.InstallScript.Type.CreateExecutor(mod, gameModeProxied, environmentInfo, installers, SynchronizationContext.Current);
// read-only transactions are waaaay faster, especially for solid archives) because the extractor isn't recreated for every extraction (why exactly would it be otherwise?)
mod.BeginReadOnlyTransaction(fileUtil);
// run the script in a second thread and start the main loop in the main thread to ensure we can handle message boxes and the like
ScriptRunner runner = new ScriptRunner(executor, mod.InstallScript);
runner.Execute();
runner.TaskEnded += delegate
{
iniIniInstaller.FinalizeInstall();
gameSpecificValueInstaller.FinalizeInstall();
mod.EndReadOnlyTransaction();
Application.Exit();
};
Application.Run();
switch (runner.Status)
{
case BackgroundTasks.TaskStatus.Cancelled: return(11);
case BackgroundTasks.TaskStatus.Error: return(6);
case BackgroundTasks.TaskStatus.Incomplete: return(10);
default: return(0);
}
}
else
{
errorString = "no install script";
return(4);
}
}
catch (Exception e)
{
Console.WriteLine("exception: " + e.Message);
MessageBox.Show(e.Message, "Installation failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(5);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object" /> class.
/// </summary>
public InterfaceWrapper(T instance, MappingRules <T> rules)
{
Target = typeof(T).IsInterface ? Generator.CreateInterfaceProxyWithTarget(instance, new Interceptor(rules, this, instance)) : Generator.CreateClassProxyWithTarget(instance, new Interceptor(rules, this, instance));
}
static TContextType CreateProxiedContext(TContextType context)
{
return(Generator.CreateClassProxyWithTarget(context,
new ScenarioContextInterceptor()));
}
public void Intercept(IInvocation invocation)
{
bool modifiedAskToWait = false;
if (IsLro(invocation.Method.ReturnType))
{
WaitUntil current = (WaitUntil)invocation.Arguments[0];
if (current == WaitUntil.Completed)
{
modifiedAskToWait = true;
invocation.Arguments[0] = WaitUntil.Started;
}
}
invocation.Proceed();
if (modifiedAskToWait)
{
if (IsTaskFaulted(invocation.ReturnValue))
{
return;
}
object lro = GetResultFromTask(invocation.ReturnValue);
if (lro.GetType().IsSubclassOf(typeof(Operation)))
{
_ = OperationInterceptor.InvokeWaitForCompletionResponse(lro as Operation, (CancellationToken)invocation.Arguments.Last());
}
else
{
_ = OperationInterceptor.InvokeWaitForCompletion(lro, lro.GetType(), (CancellationToken)invocation.Arguments.Last());
}
return;
}
var result = invocation.ReturnValue;
if (result == null)
{
return;
}
var type = result.GetType();
if (IsTaskType(type))
{
if (IsTaskFaulted(result))
{
return;
}
var taskResultType = type.GetGenericArguments()[0];
if (taskResultType.Name.StartsWith("Response") || InheritsFromArmResource(taskResultType))
{
var taskResult = GetResultFromTask(result);
var instrumentedResult = _testBase.InstrumentClient(taskResultType, taskResult, new IInterceptor[] { new ManagementInterceptor(_testBase) });
invocation.ReturnValue = type.Name.StartsWith("ValueTask")
? GetValueFromValueTask(taskResultType, instrumentedResult)
: GetValueFromOther(taskResultType, instrumentedResult);
}
}
else if (invocation.Method.Name.EndsWith("Value") && InheritsFromArmResource(type))
{
invocation.ReturnValue = _testBase.InstrumentClient(type, result, new IInterceptor[] { new ManagementInterceptor(_testBase) });
}
else if (type.BaseType.Name.StartsWith("AsyncPageable"))
{
invocation.ReturnValue = s_proxyGenerator.CreateClassProxyWithTarget(type, result, new IInterceptor[] { new ManagementInterceptor(_testBase) });
}
else if (invocation.Method.Name.StartsWith("Get") &&
invocation.Method.Name.EndsWith("Enumerator") &&
type.IsGenericType &&
InheritsFromArmResource(type.GetGenericArguments().First()))
{
var wrapperType = typeof(AsyncPageableInterceptor <>);
var genericType = wrapperType.MakeGenericType(type.GetGenericArguments()[0]);
var ctor = genericType.GetConstructor(new Type[] { typeof(ClientTestBase), result.GetType() });
invocation.ReturnValue = ctor.Invoke(new object[] { _testBase, result });
}
}
public object Intercept(object objectToIntercept)
{
var interceptor = CreateInterceptor(objectToIntercept);
return(Generator.CreateClassProxyWithTarget(objectToIntercept.GetType(), objectToIntercept, ProxyGenerationOptions.Default, interceptor));
}
public void Intercept(IInvocation invocation)
{
invocation.Proceed();
var result = invocation.ReturnValue;
if (result == null)
{
return;
}
var type = result.GetType();
if (type.Name.StartsWith("ValueTask") ||
type.Name.StartsWith("Task") ||
type.Name.StartsWith("AsyncStateMachineBox")) //in .net 5 the type is not task here
{
if ((bool)type.GetProperty("IsFaulted").GetValue(result))
{
return;
}
var taskResultType = type.GetGenericArguments()[0];
if (taskResultType.Name.StartsWith("Response"))
{
try
{
var taskResult = result.GetType().GetProperty("Result").GetValue(result);
var instrumentedResult = _testBase.InstrumentClient(taskResultType, taskResult, new IInterceptor[] { new ManagementInterceptor(_testBase) });
invocation.ReturnValue = type.Name.StartsWith("ValueTask")
? GetValueFromValueTask(taskResultType, instrumentedResult)
: GetValueFromOther(taskResultType, instrumentedResult);
}
catch (TargetInvocationException e)
{
if (e.InnerException is AggregateException aggException)
{
throw aggException.InnerExceptions.First();
}
else
{
throw e.InnerException;
}
}
}
}
else if (invocation.Method.Name.EndsWith("Value") && type.BaseType.Name.EndsWith("Operations"))
{
invocation.ReturnValue = _testBase.InstrumentClient(type, result, new IInterceptor[] { new ManagementInterceptor(_testBase) });
}
else if (type.BaseType.Name.StartsWith("AsyncPageable"))
{
invocation.ReturnValue = s_proxyGenerator.CreateClassProxyWithTarget(type, result, new IInterceptor[] { new ManagementInterceptor(_testBase) });
}
else if (invocation.Method.Name.StartsWith("Get") &&
invocation.Method.Name.EndsWith("Enumerator") &&
type.IsGenericType &&
InheritsFromOperationBase(type.GetGenericArguments().First()))
{
var wrapperType = typeof(AsyncPageableInterceptor <>);
var genericType = wrapperType.MakeGenericType(type.GetGenericArguments()[0]);
var ctor = genericType.GetConstructor(new Type[] { typeof(ClientTestBase), result.GetType() });
invocation.ReturnValue = ctor.Invoke(new object[] { _testBase, result });
}
}
//This is how we get ActualClass items that are wrapped in the Dynamic Proxy
public static ActualClass getActualClassInstance()
{
ActualClass instance = new ActualClass();
return(pg.CreateClassProxyWithTarget <ActualClass>(instance, interceptor));
}