public void GetReleaseExport_NonSharedPart_ShouldNotRecomposeAfterRelease()
{
var catalog = new TypeCatalog(typeof(NonSharedPartRecomposable));
var container = new CompositionContainer(catalog);
// Setup dependency
CompositionBatch batch = new CompositionBatch();
var valueKey = batch.AddExportedValue("Value", 21);
container.Compose(batch);
var export = container.GetExport <NonSharedPartRecomposable>();
var exportedValue = export.Value;
Assert.AreEqual(21, exportedValue.Value);
container.ReleaseExport(export);
// Recompose just to ensure we don't blow up, even though we don't expect anything to happen.
batch = new CompositionBatch();
batch.RemovePart(valueKey);
batch.AddExportedValue("Value", 42);
container.Compose(batch);
Assert.AreEqual(21, exportedValue.Value, "Value should not be recomposed after ReleaseExport is called on it.");
}
private void Run()
{
var aggregateCatalog = new AggregateCatalog();
using (var container = new CompositionContainer(aggregateCatalog))
{
container.ComposeParts(this);
//Check if the field is injected. It shouldn't be since the
//NonShared type is not known to the container yet..
Console.WriteLine("NonShared field {0}", this._nonShared != null ? "exists" : "does not exist");
//Add the NonShared type to a type catalog.
var typeCatalog = new TypeCatalog(typeof(NonShared));
//Add the TypeCatalog to the AggregateCatalog.
aggregateCatalog.Catalogs.Add(typeCatalog);
//Check if the field is injected. This time it should be.
Console.WriteLine("NonShared field {0}", this._nonShared != null ? "exists" : "does not exist");
if (this._nonShared != null)
{
//Access the lazy object so it gets a value.
this._nonShared.Value.ToString();
//Release the part. The Dispose method should be called.
container.ReleaseExport <NonShared>(this._nonShared);
}
}
}
private DoStepsHostView GetDoStepsView(ContentURI uri,
string extensionTypeName)
{
DoStepsHostView hostview = null;
try
{
//directory storing extensions (webproject apppath (c:\Devtreks)
//extension projects use the project's post build event to copy their dlls there
string sExtensionRoot = DataHelpers.AppSettings.GetExtensionsRelPath(uri);
CompositionContainer container
= GetCompositionContainerFromDirectory(sExtensionRoot);
container.ComposeParts(this);
foreach (var calculatorView in calculatorViews)
{
//the export attributes will change in future upgrades
//extensiontypename (a parameter stored in db) determines extension to run
if (calculatorView.Metadata.CONTRACT_TYPE
== CALULATOR_CONTRACT_TYPES.defaultcalculatormanager &&
calculatorView.Metadata.CalculatorsExtensionName.ToLower()
== extensionTypeName.ToLower())
{
hostview = calculatorView.Value;
container.ReleaseExport(calculatorView);
break;
}
}
}
catch (CompositionException cex)
{
uri.ErrorMessage = cex.ToString();
}
return(hostview);
}
/// <summary>
/// <see cref="M:System.IDisposable.Dispose"/>
/// </summary>
/// <param name="disposing">False if unmanaged resources must be disposed, false otherwise.</param>
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
compositionContainer.ReleaseExport(application);
application = null;
}
disposed = true;
}
public override void ReleaseController(IController controller)
{
lock (_syncRoot)
{
var export = _exports[controller];
_exports.Remove(controller);
_container.ReleaseExport(export);
}
base.ReleaseController(controller);
}
public void ReleaseParsleyAsTransientDisposesParsley()
{
var catalog = new TypeCatalog(typeof(Ploeh.Samples.Menu.Mef.Attributed.Lifetime.NonShared.Parsley));
var container = new CompositionContainer(catalog);
var x = container.GetExport <IIngredient>();
var ingredient = x.Value;
container.ReleaseExport(x);
var parsley = Assert.IsAssignableFrom <Parsley>(ingredient);
Assert.True(parsley.IsDisposed);
}
static void Main(string[] args)
{
AssemblyCatalog catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
CompositionContainer container = new CompositionContainer(catalog);
var classA = container.GetExport <ClassA>();
var instance = classA.Value;
//then we will use the generic ReleaseExport method and gie it the lazy instance we got from the container.
container.ReleaseExport <ClassA>(classA);
//Finally we will dispose the container.
container.Dispose();
Console.ReadKey();
}
public void Dispose()
{
if (!_stopped)
{
_stopped = true;
_service?.RemoveListener(this);
_tcpListener?.Stop();
Authenticator = null;
if (null != _mefContainer)
{
if (null != _export)
{
_mefContainer.ReleaseExport(_export);
}
_mefContainer.Dispose();
}
}
}
public static T GetExportedInstance <T>(this CompositionContainer container)
{
try
{
var export = container.GetExport <T>();
if (export != null)
{
T instance = export.Value;
container.ReleaseExport(export);
return(instance);
}
return(default(T));
}
catch (Exception x)
{
Console.WriteLine(x.ToString());
throw;
}
}
/// <summary>
/// 從容器中釋放Export對象
/// </summary>
/// <param name="export">要釋放的Export對象</param>
public void ReleaseExport(Export export)
{
_container.ReleaseExport(export);
}
/// <summary>
/// Releases an export
/// </summary>
/// <typeparam name="T">Type to resolve</typeparam>
/// <param name="export">Object instance to release</param>
public static void Release <T>(Lazy <T> export)
{
Container.ReleaseExport <T>(export);
}