static Composition()
{
var pluginName = ConfigSettingHelper.GetAppStr("PluginName");
var dirCatalog = new DirectoryCatalog(".", pluginName + ".*.dll");
container = new System.ComponentModel.Composition.Hosting.CompositionContainer(dirCatalog);
}
public void Load(IModuleConfiguration config, string modulePackagesPath, string extension, params string[] moduleNames)
{
_logger.Debug("Loading modules from: " + modulePackagesPath);
var paths = _resolver.GetAssemblyPaths(modulePackagesPath, string.Empty);
var catalog = new AggregateCatalog();
foreach (var path in paths)
{
_addToCatalog(path, catalog);
}
var container = new CompositionContainer(catalog);
var lazyModules = _getModules(container);
var modules = lazyModules
.Where(m => moduleNames.Contains(m.Metadata.Name) ||
(extension != null && m.Metadata.Extensions != null && (m.Metadata.Extensions.Split(',').Contains(extension))))
.Select(m => m.Value);
_logger.Debug("Initializing modules");
foreach (var module in modules)
{
_logger.Debug(string.Format("Initializing module:{0}", module.GetType().FullName));
module.Initialize(config);
}
_logger.Debug("Modules initialized");
}
public App()
{
var cmdArgs = Environment.GetCommandLineArgs().Skip(1);
App.CommandLineArguments = new CommandLineArguments(cmdArgs);
if (App.CommandLineArguments.SingleInstance ?? true) {
cmdArgs = cmdArgs.Select(FullyQualifyPath);
string message = string.Join(Environment.NewLine, cmdArgs);
if (SendToPreviousInstance("ILSpy:\r\n" + message, !App.CommandLineArguments.NoActivate)) {
Environment.Exit(0);
}
}
InitializeComponent();
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(typeof(App).Assembly));
catalog.Catalogs.Add(new DirectoryCatalog(".", "*.Plugin.dll"));
compositionContainer = new CompositionContainer(catalog);
Languages.Initialize(compositionContainer);
if (!Debugger.IsAttached) {
AppDomain.CurrentDomain.UnhandledException += ShowErrorBox;
Dispatcher.CurrentDispatcher.UnhandledException += Dispatcher_UnhandledException;
}
EventManager.RegisterClassHandler(typeof(Window),
Hyperlink.RequestNavigateEvent,
new RequestNavigateEventHandler(Window_RequestNavigate));
}
public static Expression Resolve(this Expression source, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container)
{
if (cc == null)
{
cc = new CodeContext();
}
// It does happen that we are asked to translate a null expression. This could be a static method call, for example.
if (source == null)
return null;
try
{
Debug.WriteLine("Expression Resolver: Resolving {0}{1}", source.ToString(), "");
Debug.Indent();
var r = ResolveToExpression.Translate(source, gc, cc, container);
Debug.WriteLine("Expression Resolver: Result: {0}{1}", r == null ? "<null>" : r.ToString(), "");
return r;
}
finally
{
Debug.Unindent();
}
}
public Runner Init(IFeedbackProvider feedbackProvider, string[] args)
{
var catalog = new AggregateCatalog(new AssemblyCatalog(typeof(Bootstrapper).Assembly));
var currentDir = Environment.CurrentDirectory;
var assemblyDir = new FileInfo(new Uri(Assembly.GetExecutingAssembly().CodeBase).AbsolutePath).Directory.FullName;
var paths = new string[]
{
assemblyDir,
Path.Combine(assemblyDir, "Tasks"),
currentDir,
Path.Combine(currentDir, "Tasks")
}.Unique();
var dirCatalogs = paths.Where(x => Directory.Exists(x))
.Select(x => new DirectoryCatalog(x, "*.Tasks.dll"));
dirCatalogs.Apply(x => catalog.Catalogs.Add(x));
var container = new CompositionContainer(catalog);
var parsed = new ArgumentParser().Parse(args);
var runner = new Runner(parsed.ActualArgs.ToArray());
var batch = new CompositionBatch();
batch.AddExportedValue<IFeedbackProvider>(feedbackProvider);
parsed.Options.Apply(x => batch.AddExportedValue<string>(x.Item1, x.Item2));
parsed.Switches.Apply(x => batch.AddExportedValue<bool>(x, true));
batch.AddPart(runner);
container.Compose(batch);
return runner;
}
public void LoadPlugins(IEnumerable<ComposablePartCatalog> catalogs = null)
{
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(GetType().Assembly));
if (catalogs != null)
{
foreach (var additionalCatalog in catalogs)
{
catalog.Catalogs.Add(additionalCatalog);
}
}
//Create the CompositionContainer with the parts in the catalog
Container = new CompositionContainer(catalog);
//Fill the imports of this object
try
{
Container.ComposeParts(this);
}
catch (CompositionException compositionException)
{
Console.WriteLine(compositionException.ToString());
}
}
private bool Compose()
{
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(typeof(IMefShapesGame).Assembly));
catalog.Catalogs.Add(new AssemblyCatalog(typeof(DefaultDimensions).Assembly));
var partCreatorEP = new DynamicInstantiationExportProvider();
this._container = new CompositionContainer(catalog, partCreatorEP);
partCreatorEP.SourceProvider = this._container;
CompositionBatch batch = new CompositionBatch();
batch.AddPart(this);
batch.AddExportedValue<ICompositionService>(this._container);
batch.AddExportedValue<AggregateCatalog>(catalog);
try
{
this._container.Compose(batch);
}
catch (CompositionException compositionException)
{
MessageBox.Show(compositionException.ToString());
Shutdown(1);
return false;
}
return true;
}
/// <summary>
/// This method loads the plugins.
/// </summary>
private void AssembleComponents()
{
var catalog = new AggregateCatalog();
//Note: we load not only from the plugins folder, but from this assembly as well.
var executingAssemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
if (Directory.Exists(Environment.CurrentDirectory + "\\Plugins"))
{
catalog.Catalogs.Add(new DirectoryCatalog("Plugins"));
}
catalog.Catalogs.Add(executingAssemblyCatalog);
var container = new CompositionContainer(catalog);
try
{
container.ComposeParts(this);
}
catch (CompositionException compositionException)
{
_dialogService.ShowMessageAsync(_mainVm, "Error", string.Format("There was an error loading plugins: {0}", compositionException)).Forget();
}
}
public ModuleOne(IRegionManager regionManager, CompositionContainer container)
{
if(regionManager == null) throw new ArgumentNullException("regionManager");
if(container == null) throw new ArgumentNullException("container");
_regionManager = regionManager;
_container = container;
}
public FileController(CompositionContainer container, IMessageService messageService, IFileDialogService fileDialogService,
IShellService shellService, FileService fileService)
{
this.container = container;
this.messageService = messageService;
this.fileDialogService = fileDialogService;
this.shellService = shellService;
this.fileService = fileService;
this.documentTypes = new List<IDocumentType>();
this.newDocumentCommand = new DelegateCommand(NewDocumentCommand, CanNewDocumentCommand);
this.closeDocumentCommand = new DelegateCommand(CloseDocumentCommand, CanCloseDocumentCommand);
this.saveDocumentCommand = new DelegateCommand(SaveDocumentCommand, CanSaveDocumentCommand);
this.saveAllDocumentCommand = new DelegateCommand(SaveAllDocumentCommand, CanSaveAllDocumentCommand);
this.newSolutionCommand = new DelegateCommand(NewSolutionCommand);
this.openSolutionCommand = new DelegateCommand(OpenSolutionCommand);
this.closeSolutionCommand = new DelegateCommand(CloseSolutionCommand, CanCloseSolutionCommand);
this.showSolutionCommand = new DelegateCommand(ShowSolutionCommand, CanShowSolutionCommand);
this.fileService.NewDocumentCommand = this.newDocumentCommand;
this.fileService.CloseDocumentCommand = this.closeDocumentCommand;
this.fileService.SaveDocumentCommand = this.saveDocumentCommand;
this.fileService.SaveAllDocumentCommand = this.saveAllDocumentCommand;
this.fileService.NewSolutionCommand = this.newSolutionCommand;
this.fileService.OpenSolutionCommand = this.openSolutionCommand;
this.fileService.CloseSolutionCommand = this.closeSolutionCommand;
this.fileService.ShowSolutionCommand = this.showSolutionCommand;
this.recentSolutionList = Settings.Default.RecentSolutionList;
if (this.recentSolutionList == null) { this.recentSolutionList = new RecentFileList(); }
this.fileService.RecentSolutionList = recentSolutionList;
AddWeakEventListener(fileService, FileServicePropertyChanged);
}
private static IRun CreateRun()
{
ThreadPool.SetMinThreads(32, 32);
var args = ParseArguments();
var compositionContainer = new CompositionContainer(new AssemblyCatalog(typeof(Program).Assembly));
compositionContainer.ComposeExportedValue(new RunData
{
SampleRate = args.SampleRate,
Warmup = args.Warmup,
Duration = args.Duration,
Connections = args.Connections,
Payload = GetPayload(args.PayloadSize),
Senders = args.Senders,
Transport = args.Transport,
Host = args.Host,
Url = args.Url,
SendDelay = args.SendDelay,
// Scaleout
RedisServer = args.RedisServer,
RedisPort = args.RedisPort,
RedisPassword = args.RedisPassword,
ServiceBusConnectionString = args.ServiceBusConnectionString,
SqlConnectionString = args.SqlConnectionString,
SqlTableCount = args.SqlTableCount,
});
return compositionContainer.GetExportedValue<IRun>(args.RunName);
}
/// <summary>
/// Default private constructor.
/// </summary>
private ExtensionManager()
{
if (!Config.DisableComposition)
{
// Let MEF scan for imports
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(Config.DisableCatalogSearch ? new DirectoryCatalog("Bin", "Piranha*.dll") : new DirectoryCatalog("Bin"));
#if !NET40
if (!System.Web.Compilation.BuildManager.IsPrecompiledApp)
{
#endif
try
{
// This feature only exists for Web Pages
catalog.Catalogs.Add(new AssemblyCatalog(Assembly.Load("App_Code")));
}
catch { }
#if !NET40
}
#endif
Container = new CompositionContainer(catalog);
Container.ComposeParts(this);
}
}
public void ComposeParts(object target)
{
var path = PathProvider.BinaryPath;
var directoryCatalog = new DirectoryCatalog(path);
var container = new CompositionContainer(directoryCatalog);
container.ComposeParts(target);
}
public void Initialize()
{
container = new CompositionContainer(
new AggregateCatalog(
new AssemblyCatalog(
typeof (ITypedPool).Assembly
),
new TypeCatalog(typeof (Registrator)),
new TypeCatalog(typeof (ResourcePool)),
new TypeCatalog(typeof (NotifiedElementGetter)),
new TypeCatalog(typeof(NotifiedElementPoster)),
new TypeCatalog(typeof (UnnotifiedElementGetter)),
new TypeCatalog(typeof (UnnotifiedElementPoster))));
_uplink = _mockRepository.DynamicMock<AnnouncerUplink>();
_downlink = _mockRepository.DynamicMock<AnnouncerDownlink>();
_downlink.Expect(k => k.Subscribe(null))
.IgnoreArguments()
.Repeat.Once();
_downlink.Replay();
container.ComposeExportedValue(_uplink);
container.ComposeExportedValue(_downlink);
//_poster = _mockRepository.DynamicMock<NotifiedElementPoster>();
//_posterFactory = _mockRepository.DynamicMock<IPacketResourcePoster>();
// container.ComposeExportedValue<ResourcePoster>(_poster);
container.ComposeExportedValue(_posterFactory);
_pool = container.GetExportedValue<ITypedPool>();
_subscriptor = container.GetExportedValue<IAnnouncerSubscriptor>();
var service = container.GetExportedValue<ICacheServicing>();
service.Initialize(new Settings
{
}, container);
}
public override void Invoke(CompositionContainer container)
{
TemplateInfo templateInfo;
if (!this.TemplateResolver.TryResolve(this.Template, out templateInfo))
Console.WriteLine("Template not found: '{0}'.", this.Template);
do
{
foreach (string filename in templateInfo.GetFiles())
{
Console.WriteLine(filename);
string targetPath = System.IO.Path.Combine(this.Path, filename);
string targetDir = System.IO.Path.GetDirectoryName(targetPath);
Directory.CreateDirectory(targetDir);
using (var target = new FileStream(targetPath, FileMode.CreateNew, FileAccess.Write, FileShare.None))
using (var content = templateInfo.Source.OpenFile(filename, FileMode.Open))
{
content.CopyTo(target);
content.Close();
target.Close();
}
}
templateInfo = templateInfo.Inherits;
} while (this.IncludeInherited && templateInfo != null);
}
void LoadPlugins() {
try{
var pluginsPath = Utils.MapPath("~/plugins");
if (!Directory.Exists(pluginsPath)) {
plugins = Enumerable.Empty<IPlugin>();
return;
}
var catalog = new DirectoryCatalog(pluginsPath);
var container = new CompositionContainer(catalog);
container.SatisfyImportsOnce(this);
} catch (Exception err) {
//swallow error
log.WriteError(String.Format("error during loading plugins: {0}", err.Message));
dbg.Break();
plugins = Enumerable.Empty<IPlugin>();
}
foreach (var p in plugins) {
try {
p.Init();
} catch (Exception err) {
//swallow error
log.WriteError(String.Format("error during plugin initialization: {0}", err.Message));
dbg.Break();
}
}
}
public void TestMefStatusReportable()
{
string dir = AssemblyDirectory;
//Lets get the nlog status reportable from MEF directory..
CompositionContainer _container;
//An aggregate catalog that combines multiple catalogs
var catalog = new AggregateCatalog();
//Adds all the parts found in the same assembly as the Program class
catalog.Catalogs.Add(new AssemblyCatalog(typeof(TestMEF).Assembly));
catalog.Catalogs.Add(new DirectoryCatalog(AssemblyDirectory));
//Create the CompositionContainer with the parts in the catalog
_container = new CompositionContainer(catalog);
//Fill the imports of this object
try
{
_container.ComposeParts(this);
}
catch (CompositionException compositionException)
{
Console.WriteLine(compositionException.ToString());
}
reporter.Report(2,1,"Test Report");
}
public void Initialize()
{
var catalog = new AggregateCatalog();
//Adds the program's assembly
catalog.Catalogs.Add(new AssemblyCatalog(typeof(PluginInfrastructre).Assembly));
string programassembly = System.Reflection.Assembly.GetAssembly(typeof(PluginInfrastructre)).Location;
string programpath = Path.GetDirectoryName(programassembly);
//add the program's path
catalog.Catalogs.Add(new DirectoryCatalog(programpath));
_container = new CompositionContainer(catalog);
try
{
//Initialize types found and assign new instances to Plugins
Plugins = _container.GetExportedValues<IPlugin>();
}
catch (CompositionException compositionException)
{
throw;
}
}
/// <summary>
/// Actually try and process this! The count consisits of a count integer and something to increment it
/// at its current spot.
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="codeEnv"></param>
/// <returns></returns>
public Expression ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container)
{
if (gc == null)
throw new ArgumentNullException("CodeEnv must not be null!");
var c = resultOperator as CountResultOperator;
if (c == null)
throw new ArgumentNullException("resultOperator can only be a CountResultOperator and must not be null");
//
// The accumulator where we will store the result.
//
var accumulator = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
accumulator.SetInitialValue("0");
//
// Use the Aggregate infrasturcutre to do the adding. This
// has the advantage that it will correctly combine with
// similar statements during query optimization.
//
var add = Expression.Add(accumulator, Expression.Constant((int)1));
var addResolved = ExpressionToCPP.GetExpression(add, gc, cc, container);
gc.Add(new StatementAggregate(accumulator, addResolved));
return accumulator;
}
private static IList<IContentProvider> GetContentProviders(IKernel kernel)
{
// Use MEF to locate the content providers in this assembly
var compositionContainer = new CompositionContainer(new AssemblyCatalog(typeof(ResourceProcessor).Assembly));
compositionContainer.ComposeExportedValue(kernel);
return compositionContainer.GetExportedValues<IContentProvider>().ToList();
}
public TestHarness(string pluginDirectoryPath, Type pluginAssemblyType, string pluginType)
{
var catalog = new AggregateCatalog();
this._pluginType = pluginType;
try
{
Assembly[] assemblies = new Assembly[]{ Assembly.GetCallingAssembly(), Assembly.GetExecutingAssembly(), Assembly.GetEntryAssembly() };
foreach (Assembly assembly in assemblies)
{
catalog.Catalogs.Add(new AssemblyCatalog(assembly));
catalog.Catalogs.Add(new DirectoryCatalog(Path.GetDirectoryName(assembly.Location)));
}
if (!Object.ReferenceEquals(pluginAssemblyType, null))
{
catalog.Catalogs.Add(new AssemblyCatalog(pluginAssemblyType.Assembly));
}
if (!Object.ReferenceEquals(pluginDirectoryPath, null))
{
if (Directory.Exists(pluginDirectoryPath))
{
catalog.Catalogs.Add(new DirectoryCatalog(pluginDirectoryPath));
}
}
this.container = new CompositionContainer(catalog);
this.container.ComposeParts(this);
}
catch (CompositionException cex)
{
Console.WriteLine(cex.ToString());
}
}
private bool Compose()
{
var catalog = new System.ComponentModel.Composition.Hosting.AggregateCatalog();
// var catalog = new AggregatingComposablePartCatalog();
catalog.Catalogs.Add(
new RubyCatalog(new RubyPartFile("calculator_ops.rb")));
catalog.Catalogs.Add(
new AssemblyCatalog(Assembly.GetExecutingAssembly()));
_container = new System.ComponentModel.Composition.Hosting.CompositionContainer(catalog);
//_container. AddPart(this);
var batch = new System.ComponentModel.Composition.Hosting.CompositionBatch();
batch.AddPart(this);
//_container.AddPart(this);
//_container.Compose(this);
try
{
_container.Compose(batch);
}
catch (CompositionException compositionException)
{
MessageBox.Show(compositionException.ToString());
return false;
}
return true;
}
private static void ComposeConnectionFactory()
{
try
{
using (var catalog = new DirectoryCatalog(AppDomain.CurrentDomain.BaseDirectory))
using (var container = new CompositionContainer(catalog))
{
var export = container.GetExportedValueOrDefault<IConnectionFactory>();
if (export != null)
{
Factory = export;
Console.WriteLine("Using {0}", Factory.GetType());
}
}
}
catch (ImportCardinalityMismatchException)
{
Console.WriteLine("More than one IConnectionFactory import was found.");
}
catch (Exception e)
{
Console.WriteLine(e);
}
if (Factory == null)
{
Factory = new DefaultConnectionFactory();
Console.WriteLine("Using default connection factory...");
}
}
public void DualContainers()
{
var container1 = new CompositionContainer();
TypeDescriptorServices dat1 = new TypeDescriptorServices();
CompositionBatch batch = new CompositionBatch();
batch.AddPart(dat1);
container1.Compose(batch);
MetadataStore.AddAttribute(
typeof(DynamicMetadataTestClass),
( type, attributes) =>
Enumerable.Concat(
attributes,
new Attribute[] { new TypeConverterAttribute(typeof(DynamicMetadataTestClassConverter)) }
),
container1
);
var container2 = new CompositionContainer();
CompositionBatch batch2 = new CompositionBatch();
TypeDescriptorServices dat2 = new TypeDescriptorServices();
batch2.AddPart(dat2);
container2.Compose(batch2);
DynamicMetadataTestClass val = DynamicMetadataTestClass.Get("42");
var attached1 = dat1.GetConverter(val.GetType());
Assert.IsTrue(attached1.CanConvertFrom(typeof(string)), "The new type converter for DynamicMetadataTestClass should support round tripping");
var attached2 = dat2.GetConverter(val.GetType());
Assert.IsFalse(attached2.CanConvertFrom(typeof(string)), "The default type converter for DynamicMetadataTestClass shouldn't support round tripping");
}
private void Application_Startup(object sender, StartupEventArgs e)
{
Container = new CompositionContainer(new DeploymentCatalog());
CompositionHost.Initialize(Container);
CompositionInitializer.SatisfyImports(this);
RootVisual = new Commodities();
}
public void DoImport()
{
//An aggregate catalog that combines multiple catalogs
var catalog = new AggregateCatalog();
directoryCatalog = new DirectoryCatalog(GetDirectory());
directoryCatalog.Changing += directoryCatalog_Changing;
directoryCatalog.Changed += directoryCatalog_Changed;
//Adds all the parts found in all assemblies in
//the same directory as the executing program
catalog.Catalogs.Add(directoryCatalog);
//Create the CompositionContainer with the parts in the catalog
var container = new CompositionContainer(catalog);
try
{
//Fill the imports of this object
container.ComposeParts(this);
}
catch (Exception ex)
{
Out.WriteLine("Unable to load plugins: {0}", ex.Message);
}
}
internal CompositionService(ComposablePartCatalog composablePartCatalog)
{
Assumes.NotNull(composablePartCatalog);
this._notifyCatalog = composablePartCatalog as INotifyComposablePartCatalogChanged;
try
{
if(this._notifyCatalog != null)
{
this._notifyCatalog.Changing += this.OnCatalogChanging;
}
var compositionOptions = CompositionOptions.DisableSilentRejection | CompositionOptions.IsThreadSafe | CompositionOptions.ExportCompositionService;
var compositionContainer = new CompositionContainer(composablePartCatalog, compositionOptions);
this._compositionContainer = compositionContainer;
}
catch
{
if(this._notifyCatalog != null)
{
this._notifyCatalog.Changing -= this.OnCatalogChanging;
}
throw;
}
}
//Change to allow for Multi- Tenancy cases
//User has to call this method every time he creates a new tenant DB
public static void CreateOrUpdateUserAuthIndex(IDocumentStore store,string databaseName)
{
// put this index into the ravendb database
var catalog = new CompositionContainer(new AssemblyCatalog(typeof(ServiceStack_UserAuth_ByUserNameOrEmail).Assembly));
IndexCreation.CreateIndexes(catalog, store.DatabaseCommands.ForDatabase(databaseName), store.Conventions);
_isInitialized = true;
}
/// <summary>
/// MEF Bootstrap (MEF comes from System.ComponentModel.Composition in the GAC).
/// <para>This will return a class containing all the application's aggregate roots.</para>
/// </summary>
public static ComposedDemoProgram Configure(params string[] pluginDirectories)
{
var catalogues =
pluginDirectories.Select<string, ComposablePartCatalog>(d=>new DirectoryCatalog(d)).
Concat(new []{new AssemblyCatalog(Assembly.GetExecutingAssembly())}).ToList();
var catalog = new AggregateCatalog(catalogues);
try
{
var container = new CompositionContainer(catalog);
var composedProgram = new ComposedDemoProgram();
container.SatisfyImportsOnce(composedProgram);
return composedProgram;
}
finally
{
catalog.Dispose();
foreach (var cat in catalogues)
{
cat.Dispose();
}
}
}
static async Task AsyncMain()
{
AggregateCatalog catalog = new AggregateCatalog();
catalog.Catalogs.Add(new DirectoryCatalog("."));
CompositionContainer compositionContainer = new CompositionContainer(catalog);
Console.Title = "Samples.MefExtensionEndpoint";
LogManager.Use<DefaultFactory>().Level(LogLevel.Info);
EndpointConfiguration endpointConfiguration = new EndpointConfiguration("Samples.MefExtensionEndpoint");
endpointConfiguration.UsePersistence<InMemoryPersistence>();
endpointConfiguration.EnableInstallers();
await RunCustomizeConfiguration(compositionContainer, endpointConfiguration);
await RunBeforeEndpointStart(compositionContainer);
IEndpointInstance endpoint = await Endpoint.Start(endpointConfiguration);
await RunAfterEndpointStart(compositionContainer, endpoint);
try
{
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await RunBeforeEndpointStop(compositionContainer, endpoint);
await endpoint.Stop();
}
await RunAfterEndpointStop(compositionContainer);
}
public FilterContext(ObjectCache cache, CompositionContainer container, IAssetResolver assetResolver, FilterState state)
{
this.Container = container;
this.Cache = cache;
this.AssetResolver = assetResolver;
this.State = state;
}
/// <summary>
/// Expressions that are actually code are left alone at the early stage.
/// </summary>
/// <param name="expr"></param>
/// <param name="gc"></param>
/// <param name="context"></param>
/// <param name="container"></param>
/// <returns></returns>
public Expression ProcessMethodCall(MethodCallExpression expr, IGeneratedQueryCode gc, ICodeContext context, System.ComponentModel.Composition.Hosting.CompositionContainer container)
{
return(expr);
}
public CompositionServiceShim(CompositionContainer innerContainer)
{
ArgumentNullException.ThrowIfNull(innerContainer);
_innerContainer = innerContainer;
}
/// <summary>
/// This should never ever happen - there is no such thing as passing over a
/// constant reference of one of these guys!
/// </summary>
/// <param name="expr"></param>
/// <param name="codeEnv"></param>
/// <param name="context"></param>
/// <param name="container"></param>
/// <returns></returns>
public IValue ProcessConstantReference(ConstantExpression expr, IGeneratedQueryCode codeEnv, System.ComponentModel.Composition.Hosting.CompositionContainer container)
{
throw new NotImplementedException();
}
internal static bool TryGetOrCreateContainer(Func <CompositionContainer> createContainer, out CompositionContainer globalContainer)
{
bool alreadyCreated = true;
if (_container == null)
{
var container = createContainer.Invoke();
lock (_lockObject)
{
if (_container == null)
{
Thread.MemoryBarrier();
_container = container;
alreadyCreated = false;
}
}
}
globalContainer = _container;
return(alreadyCreated);
}
/// <summary>
/// These are static classes as far as we are concerned - so they should never be able to run.
/// </summary>
/// <param name="expression"></param>
/// <param name="result"></param>
/// <param name="gc"></param>
/// <param name="context"></param>
/// <param name="container"></param>
/// <returns></returns>
public System.Linq.Expressions.Expression ProcessNew(System.Linq.Expressions.NewExpression expression, out IValue result, IGeneratedQueryCode gc, System.ComponentModel.Composition.Hosting.CompositionContainer container)
{
throw new NotImplementedException();
}
/// <summary>
/// Nothing like this sort of class should appear as a constant reference - so bomb if we see it.
/// </summary>
/// <param name="expr"></param>
/// <param name="codeEnv"></param>
/// <param name="context"></param>
/// <param name="container"></param>
/// <returns></returns>
public Expression ProcessConstantReferenceExpression(ConstantExpression expr, System.ComponentModel.Composition.Hosting.CompositionContainer container)
{
throw new NotImplementedException();
}
public static void Initialize(CompositionContainer container)
{
}
public IValue ProcessMemberReference(MemberExpression expr, IGeneratedQueryCode gc, ICodeContext cc, System.ComponentModel.Composition.Hosting.CompositionContainer container)
{
throw new NotImplementedException();
}
public static void SetupTestGlobalContainer(CompositionContainer container)
{
CompositionHost._container = null;
CompositionHost.Initialize(container);
}
public CompositionServiceShim(CompositionContainer innerContainer)
{
Assumes.NotNull(innerContainer);
this._innerContainer = innerContainer;
}
public IValue CodeMethodCall(MethodCallExpression expr, IGeneratedQueryCode gc, System.ComponentModel.Composition.Hosting.CompositionContainer container)
{
return(new Variables.ValSimple("1", typeof(int)));
}
internal static bool TryGetOrCreateContainer(Func <CompositionContainer> createContainer, out CompositionContainer globalContainer)
{
bool container = true;
if (_container == null)
{
CompositionContainer compositionContainer = createContainer();
lock (_lockObject)
{
if (_container == null)
{
Thread.MemoryBarrier();
_container = compositionContainer;
container = false;
}
}
}
globalContainer = _container;
return(container);
}
