public ChecksumObjectWithChildren(Serializer serializer, string kind, params object[] children) :
base(CreateChecksum(kind, children), kind)
{
_serializer = serializer;
Children = children;
}
private static async Task<Asset> CloneMetadataReferenceAssetAsync(Serializer serializer, AssetBuilder assetBuilder, Asset asset)
{
using (var stream = SerializableBytes.CreateWritableStream())
using (var writer = new ObjectWriter(stream))
{
await asset.WriteObjectToAsync(writer, CancellationToken.None).ConfigureAwait(false);
stream.Position = 0;
using (var reader = new ObjectReader(stream))
{
var recovered = serializer.Deserialize<MetadataReference>(asset.Kind, reader, CancellationToken.None);
var assetFromStorage = assetBuilder.Build(recovered, CancellationToken.None);
Assert.Equal(asset.Checksum, assetFromStorage.Checksum);
return assetFromStorage;
}
}
}
private static async Task VerifyOptionSetsAsync(Workspace workspace, string language)
{
var assetBuilder = new AssetBuilder(workspace.CurrentSolution);
var serializer = new Serializer(workspace.Services);
var asset = assetBuilder.Build(workspace.Options, language, CancellationToken.None);
using (var stream = SerializableBytes.CreateWritableStream())
using (var writer = new ObjectWriter(stream))
{
await asset.WriteObjectToAsync(writer, CancellationToken.None).ConfigureAwait(false);
stream.Position = 0;
using (var reader = new ObjectReader(stream))
{
var recovered = serializer.Deserialize<OptionSet>(asset.Kind, reader, CancellationToken.None);
var assetFromStorage = assetBuilder.Build(recovered, language, CancellationToken.None);
Assert.Equal(asset.Checksum, assetFromStorage.Checksum);
// option should be exactly same
Assert.Equal(0, recovered.GetChangedOptions(workspace.Options).Count());
}
}
}
public async Task MetadataReference_RoundTrip_Test()
{
var hostServices = MefHostServices.Create(
MefHostServices.DefaultAssemblies.Add(typeof(Host.TemporaryStorageServiceFactory.TemporaryStorageService).Assembly));
var workspace = new AdhocWorkspace(hostServices);
var reference = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);
var serializer = new Serializer(workspace.Services);
var trees = new ChecksumTreeCollection();
var assetBuilder = new AssetBuilder(trees.CreateRootTreeNode(workspace.CurrentSolution.State));
var assetFromFile = assetBuilder.Build(reference, CancellationToken.None);
var assetFromStorage = await CloneMetadataReferenceAssetAsync(serializer, assetBuilder, assetFromFile).ConfigureAwait(false);
var assetFromStorage2 = await CloneMetadataReferenceAssetAsync(serializer, assetBuilder, assetFromStorage).ConfigureAwait(false);
}
public async Task Missing_Analyzer_Serailization_Desktop_Test()
{
var hostServices = MefHostServices.Create(
MefHostServices.DefaultAssemblies.Add(typeof(Host.TemporaryStorageServiceFactory.TemporaryStorageService).Assembly));
var workspace = new AdhocWorkspace(hostServices);
var reference = new AnalyzerFileReference("missing_reference", new MissingAnalyzerLoader());
var serializer = new Serializer(workspace.Services);
var trees = new ChecksumTreeCollection();
var assetBuilder = new AssetBuilder(trees.CreateRootTreeNode(workspace.CurrentSolution.State));
// make sure this doesn't throw
var assetFromFile = assetBuilder.Build(reference, CancellationToken.None);
var assetFromStorage = await CloneAssetAsync(serializer, assetBuilder, assetFromFile).ConfigureAwait(false);
var assetFromStorage2 = await CloneAssetAsync(serializer, assetBuilder, assetFromStorage).ConfigureAwait(false);
}
public async Task Missing_Metadata_Serailization_Test()
{
var workspace = new AdhocWorkspace();
var reference = new MissingMetadataReference();
var serializer = new Serializer(workspace.Services);
var trees = new ChecksumTreeCollection();
var assetBuilder = new AssetBuilder(trees.CreateRootTreeNode(workspace.CurrentSolution.State));
// make sure this doesn't throw
var assetFromFile = assetBuilder.Build(reference, CancellationToken.None);
var assetFromStorage = await CloneAssetAsync(serializer, assetBuilder, assetFromFile).ConfigureAwait(false);
var assetFromStorage2 = await CloneAssetAsync(serializer, assetBuilder, assetFromStorage).ConfigureAwait(false);
}
public SubTreeNode GetOrCreateSubTreeNode(ChecksumTreeCollection owner, Serializer serializer)
{
if (_lazyChecksumTree != null)
{
return _lazyChecksumTree;
}
Interlocked.CompareExchange(ref _lazyChecksumTree, new SubTreeNode(owner, serializer), null);
return _lazyChecksumTree;
}
public static Task<ChecksumCollection> GetOrCreateEmptyChecksumCollection(Serializer serializer, string kind)
{
var map = s_emptyChecksumCollectionTaskCache.GetValue(serializer, s_emptyChecksumCollectionCallback);
Task<ChecksumCollection> task;
if (map.TryGetValue(kind, out task))
{
return task;
}
return map.GetOrAdd(kind, _ => Task.FromResult(new ChecksumCollection(serializer, kind, SpecializedCollections.EmptyArray<object>())));
}
public static Task<ChecksumCollection> GetOrCreateEmptyChecksumCollectionTask(Serializer serializer, string kind)
{
var collection = GetOrCreateEmptyChecksumCollection(serializer, kind);
return s_emptyChecksumCollectionTaskCache.GetValue(collection, s_emptyChecksumCollectionTaskCallback);
}
public static ChecksumCollection GetOrCreateEmptyChecksumCollection(Serializer serializer, string kind)
{
var map = s_emptyChecksumCollectionCache.GetValue(serializer, s_emptyChecksumCollectionCallback);
ChecksumCollection collection;
if (map.TryGetValue(kind, out collection))
{
return collection;
}
return map.GetOrAdd(kind, _ => new ChecksumCollection(serializer, kind, SpecializedCollections.EmptyArray<object>()));
}
