// (C) 2001 Ximian, Inc. http://www.ximian.com
// Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
//
+// Known Problems:
+// Fix serialization compatibility with MS.NET.
+//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
using System.IO;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
+using System.Security;
+using System.Runtime.Serialization.Formatters.Binary;
-#if NET_2_0
+#if(!MOONLIGHT)
using System.Runtime.Hosting;
+using System.Security.Policy;
#endif
namespace System
{
[Serializable]
[ClassInterface (ClassInterfaceType.None)]
- [MonoTODO ("Fix serialization compatibility with MS.NET")]
-#if NET_2_0
[ComVisible (true)]
-#endif
+#if NET_2_1
+ public sealed class AppDomainSetup
+#else
public sealed class AppDomainSetup : IAppDomainSetup
+#endif
{
string application_base;
string application_name;
private LoaderOptimization loader_optimization;
bool disallow_binding_redirects;
bool disallow_code_downloads;
-#if NET_2_0
+
+#if (!MOONLIGHT)
private ActivationArguments _activationArguments;
+ AppDomainInitializer domain_initializer;
+ [NonSerialized]
+ ApplicationTrust application_trust;
+ string [] domain_initializer_args;
+#else
+ object _activationArguments;
+ object domain_initializer; // always null
+ [NonSerialized]
+ object application_trust; // dummy, always null
+ object domain_initializer_args;
#endif
+ bool disallow_appbase_probe;
+ byte [] configuration_bytes;
+
+ byte [] serialized_non_primitives;
public AppDomainSetup ()
{
loader_optimization = setup.loader_optimization;
disallow_binding_redirects = setup.disallow_binding_redirects;
disallow_code_downloads = setup.disallow_code_downloads;
+ _activationArguments = setup._activationArguments;
+ domain_initializer = setup.domain_initializer;
+ application_trust = setup.application_trust;
+ domain_initializer_args = setup.domain_initializer_args;
+ disallow_appbase_probe = setup.disallow_appbase_probe;
+ configuration_bytes = setup.configuration_bytes;
}
-#if NET_2_0
+#if (!MOONLIGHT)
public AppDomainSetup (ActivationArguments activationArguments)
{
_activationArguments = activationArguments;
// Under Windows prepend "//" to indicate it's a local file
appBase = "//" + appBase;
}
-#if NET_2_0
} else {
-#else
- // under 1.x the ":" gets a special treatment - but it doesn't make sense outside Windows
- } else if (!Environment.IsRunningOnWindows || (appBase.IndexOf (':') == -1)) {
-#endif
appBase = Path.GetFullPath (appBase);
}
return appBase;
}
-
+
public string ApplicationBase {
get { return GetAppBase (application_base); }
set { application_base = value; }
application_name = value;
}
}
-
+#if !MOONLIGHT
public string CachePath {
get {
return cache_path;
public string ConfigurationFile {
get {
- return configuration_file;
+ if (configuration_file == null)
+ return null;
+ if (Path.IsPathRooted(configuration_file))
+ return configuration_file;
+ if (ApplicationBase == null)
+ throw new MemberAccessException("The ApplicationBase must be set before retrieving this property.");
+ return Path.Combine(ApplicationBase, configuration_file);
}
set {
configuration_file = value;
license_file = value;
}
}
-
- [MonoTODO ("--share-code")]
+#endif
+ [MonoLimitation ("In Mono this is controlled by the --share-code flag")]
public LoaderOptimization LoaderOptimization {
get {
return loader_optimization;
loader_optimization = value;
}
}
-
+#if !MOONLIGHT
public string PrivateBinPath {
get {
return private_bin_path;
}
}
-#if NET_1_1
public bool DisallowBindingRedirects {
get {
return disallow_binding_redirects;
disallow_code_downloads = value;
}
}
-#endif
-#if NET_2_0
public ActivationArguments ActivationArguments {
- get { return _activationArguments; }
+ get {
+ if (_activationArguments != null)
+ return _activationArguments;
+ DeserializeNonPrimitives ();
+ return _activationArguments;
+ }
set { _activationArguments = value; }
}
-#endif
+
+ [MonoLimitation ("it needs to be invoked within the created domain")]
+ public AppDomainInitializer AppDomainInitializer {
+ get {
+ if (domain_initializer != null)
+ return domain_initializer;
+ DeserializeNonPrimitives ();
+ return domain_initializer;
+ }
+ set { domain_initializer = value; }
+ }
+
+ [MonoLimitation ("it needs to be used to invoke the initializer within the created domain")]
+ public string [] AppDomainInitializerArguments {
+ get { return domain_initializer_args; }
+ set { domain_initializer_args = value; }
+ }
+
+ [MonoNotSupported ("This property exists but not considered.")]
+ public ApplicationTrust ApplicationTrust {
+ get {
+ if (application_trust != null)
+ return application_trust;
+ DeserializeNonPrimitives ();
+ if (application_trust == null)
+ application_trust = new ApplicationTrust ();
+ return application_trust;
+ }
+ set { application_trust = value; }
+ }
+
+ [MonoNotSupported ("This property exists but not considered.")]
+ public bool DisallowApplicationBaseProbing {
+ get { return disallow_appbase_probe; }
+ set { disallow_appbase_probe = value; }
+ }
+
+ [MonoNotSupported ("This method exists but not considered.")]
+ public byte [] GetConfigurationBytes ()
+ {
+ return configuration_bytes != null ? configuration_bytes.Clone () as byte [] : null;
+ }
+
+ [MonoNotSupported ("This method exists but not considered.")]
+ public void SetConfigurationBytes (byte [] value)
+ {
+ configuration_bytes = value;
+ }
+
+ private void DeserializeNonPrimitives ()
+ {
+ lock (this) {
+ if (serialized_non_primitives == null)
+ return;
+
+ BinaryFormatter bf = new BinaryFormatter ();
+ MemoryStream ms = new MemoryStream (serialized_non_primitives);
+
+ object [] arr = (object []) bf.Deserialize (ms);
+
+ _activationArguments = (ActivationArguments) arr [0];
+ domain_initializer = (AppDomainInitializer) arr [1];
+ application_trust = (ApplicationTrust) arr [2];
+
+ serialized_non_primitives = null;
+ }
+ }
+
+ internal void SerializeNonPrimitives ()
+ {
+ object [] arr = new object [3];
+
+ arr [0] = _activationArguments;
+ arr [1] = domain_initializer;
+ arr [2] = application_trust;
+
+ BinaryFormatter bf = new BinaryFormatter ();
+ MemoryStream ms = new MemoryStream ();
+
+ bf.Serialize (ms, arr);
+
+ serialized_non_primitives = ms.ToArray ();
+ }
+#endif // !NET_2_1
}
}
projects / mono.git / blobdiff