Question

Is it possible to add some additional attributes to my components which are then set/hydrated using some custom logic/perhaps from a data store? Similar to adding some custom builder strategy in cab/unity ?

UPDATE
e.g.

assuming a class has these properties

[MyImport]  string name1 { get; set }
[MyImport]  MyType name2 { get; set }
[MyGuid]  Guid { get; set; }

with custom attributes MyImport and MyGuid which are resolved by an “extension” to MEF ( which gets executed after the [imports] are resolved ) and has code along these lines

// property SET
var valu = myDBStore.GetValue( instanceGUID, propertyInfo.Name);
propertyInfo.SetValue( instance, TypeDescripter.GetConverter(valu).ConvertTo(propertyType), null);

// property GET - for example only, used during dehydration outside of MEF !
var valu = propertyInfo.GetValue( instance, null);
myDBStore.SetValue( instanceGUID, propertyInfo.Name, TypeDescripter.GetConverter(valu).ConvertTo(typeof(string));

// the above is pseudo code only, pls no comments on correct args/syntax :)

Answer 1

EDIT

components which are then set/hydrated using some custom logic/perhaps from a data store

One can do this via an “ExportFactory”.

// "ExportFactory"
public sealed class DataStoreProvider
{
    [Export(typeof(Model))]
    public Model Item
    {
        get 
        {
            return [custom logic];
        }
    }
}

public class NeedsModel
{
    [Import(typeof(Model))]
    public Model Item { get; set; }
}

---

Initial Answer
This is possible through MEF’s Lazy<T, TMetadata>.

public interface ISomeMetadata
{
    string UsefulInfo { get; }
}

[MetadataAttribute]
[AttributeUsage(AttributeTargets.Class, AllowMultiple=false)]
public class ExportBaseAttribute : ExportAttribute, ISomeMetadata
{
    public ExportBaseAttribute(string usefulInfo)
        :base(typeof(BaseExport))
    {
        UsefulInfo = usefulInfo;
    }
    public string UsefulInfo { get; private set; }
}

// BaseExport class is not needed.. just showing advanced attribute usage.
public abstract class BaseExport { }

[ExportBase("Useful Filter Information")]
public class SomeExport : BaseExport
{
}

Then, in your host (composer), you can

[ImportMany(typeof(BaseExport))]
Lazy<BaseExport, ISomeMetadata>[] _baseExports

After you compose, you can run a LINQ filter using .Metadata

var goodExports = from export in _baseExports
                  where export.Metadata.UsefulInfo ...
                  select export;