private static async Task VerifyOptionSetsAsync(Workspace workspace, string language)
{
var assetBuilder = new CustomAssetBuilder(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 StreamObjectWriter(stream))
{
await asset.WriteObjectToAsync(writer, CancellationToken.None).ConfigureAwait(false);
stream.Position = 0;
using (var reader = new StreamObjectReader(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 TestSymbolTreeInfoSerialization()
{
var solution = GetSolution(WorkspaceKind.SingleClass);
var compilation = await solution.Projects.First().GetCompilationAsync();
var assembly = compilation.GetSpecialType(SpecialType.System_Byte).ContainingAssembly;
////var assembly = compilation.Assembly;
// create symbol tree info from assembly
var version = VersionStamp.Create();
var info = SymbolTreeInfo.CreateSourceSymbolTreeInfo(
solution, version, assembly, "", cancellationToken: CancellationToken.None);
using (var writerStream = new MemoryStream())
{
using (var writer = new StreamObjectWriter(writerStream))
{
info.WriteTo(writer);
}
using (var readerStream = new MemoryStream(writerStream.ToArray()))
using (var reader = new StreamObjectReader(readerStream))
{
var readInfo = SymbolTreeInfo.ReadSymbolTreeInfo_ForTestingPurposesOnly(reader);
info.AssertEquivalentTo(readInfo);
}
}
}
protected override void WriteTo(Stream stream, Data data, CancellationToken cancellationToken)
{
using (var writer = new StreamObjectWriter(stream, cancellationToken: cancellationToken))
{
writer.WriteString(FormatVersion);
data.TextVersion.WriteTo(writer);
data.SyntaxVersion.WriteTo(writer);
writer.WriteInt32(data.Items.Length);
foreach (var item in data.Items.OfType <TodoItem>())
{
cancellationToken.ThrowIfCancellationRequested();
writer.WriteInt32(item.Priority);
writer.WriteString(item.Message);
writer.WriteString(item.OriginalFilePath);
writer.WriteInt32(item.OriginalLine);
writer.WriteInt32(item.OriginalColumn);
writer.WriteString(item.MappedFilePath);
writer.WriteInt32(item.MappedLine);
writer.WriteInt32(item.MappedColumn);
}
}
}
private static async Task <bool> SaveAsync(
Document document, string persistenceName, string formatVersion, SyntaxTreeIndex data, CancellationToken cancellationToken)
{
Contract.Requires(!await document.IsForkedDocumentWithSyntaxChangesAsync(cancellationToken).ConfigureAwait(false));
var persistentStorageService = document.Project.Solution.Workspace.Services.GetService <IPersistentStorageService>();
try
{
using (var storage = persistentStorageService.GetStorage(document.Project.Solution))
using (var stream = SerializableBytes.CreateWritableStream())
using (var writer = new StreamObjectWriter(stream, cancellationToken: cancellationToken))
{
data.WriteVersion(writer, formatVersion);
data.WriteTo(writer);
stream.Position = 0;
return(await storage.WriteStreamAsync(document, persistenceName, stream, cancellationToken).ConfigureAwait(false));
}
}
catch (Exception e) when(IOUtilities.IsNormalIOException(e))
{
// Storage APIs can throw arbitrary exceptions.
}
return(false);
}
/// <summary>
/// this is callback from remote host side to get asset associated with checksum from VS.
/// </summary>
public async Task RequestAssetAsync(int sessionId, byte[][] checksums, string streamName)
{
try
{
Contract.ThrowIfFalse(_owner._currentSessionId == sessionId);
using (Logger.LogBlock(FunctionId.JsonRpcSession_RequestAssetAsync, streamName, _source.Token))
using (var stream = await DirectStream.GetAsync(streamName, _source.Token).ConfigureAwait(false))
{
using (var writer = new StreamObjectWriter(stream))
{
writer.WriteInt32(sessionId);
await WriteAssetAsync(writer, checksums).ConfigureAwait(false);
}
await stream.FlushAsync(_source.Token).ConfigureAwait(false);
}
}
catch (IOException)
{
// remote host side is cancelled (client stream connection is closed)
// can happen if pinned solution scope is disposed
}
catch (OperationCanceledException)
{
// rpc connection is closed.
// can happen if pinned solution scope is disposed
}
}
protected override void WriteTo(Stream stream, Data data, CancellationToken cancellationToken)
{
using (var writer = new StreamObjectWriter(stream, cancellationToken: cancellationToken))
{
writer.WriteString(FormatVersion);
data.TextVersion.WriteTo(writer);
data.SemanticVersion.WriteTo(writer);
writer.WriteString(data.DesignerAttributeArgument);
}
}
private static Checksum CreateChecksumFromStreamWriter(string kind, Action <ObjectWriter, CancellationToken> writer)
{
using (var stream = SerializableBytes.CreateWritableStream())
using (var objectWriter = new StreamObjectWriter(stream))
{
objectWriter.WriteString(kind);
writer(objectWriter, CancellationToken.None);
return(Checksum.Create(stream));
}
}
public static Checksum Create <T>(T value, string kind, Serializer serializer)
{
using (var stream = SerializableBytes.CreateWritableStream())
using (var objectWriter = new StreamObjectWriter(stream))
{
objectWriter.WriteString(kind);
serializer.Serialize(value, objectWriter, CancellationToken.None);
return(Create(stream));
}
}
public static Checksum Create(string kind, Checksum checksum)
{
using (var stream = SerializableBytes.CreateWritableStream())
using (var writer = new StreamObjectWriter(stream))
{
writer.WriteString(kind);
checksum.WriteTo(writer);
return(Create(stream));
}
}
public Checksum CreateChecksum(AnalyzerReference reference, CancellationToken cancellationToken)
{
using (var stream = SerializableBytes.CreateWritableStream())
using (var writer = new StreamObjectWriter(stream, cancellationToken: cancellationToken))
{
WriteTo(reference, writer, cancellationToken);
stream.Position = 0;
return(Checksum.Create(stream));
}
}
private static Checksum CreateChecksum(AnalyzerReference reference)
{
using (var stream = SerializableBytes.CreateWritableStream())
using (var objectWriter = new StreamObjectWriter(stream))
{
objectWriter.WriteString(WellKnownSynchronizationKinds.AnalyzerReference);
objectWriter.WriteString(reference.FullPath);
return(Checksum.Create(stream));
}
}
public static Checksum Create(IObjectWritable @object, string kind)
{
using (var stream = SerializableBytes.CreateWritableStream())
using (var objectWriter = new StreamObjectWriter(stream))
{
objectWriter.WriteString(kind);
@object.WriteTo(objectWriter);
return(Create(stream));
}
}
private Checksum CreatePortableExecutableReferenceChecksum(PortableExecutableReference reference, CancellationToken cancellationToken)
{
using (var stream = SerializableBytes.CreateWritableStream())
using (var writer = new StreamObjectWriter(stream, cancellationToken: cancellationToken))
{
WritePortableExecutableReferencePropertiesTo(reference, writer, cancellationToken);
WriteMvidsTo(TryGetMetadata(reference), writer, cancellationToken);
stream.Position = 0;
return(Checksum.Create(stream));
}
}
private async Task SerializeDiagnosticResultAsync(string streamName, DiagnosticAnalysisResultMap <string, DiagnosticAnalysisResultBuilder> result)
{
using (RoslynLogger.LogBlock(FunctionId.CodeAnalysisService_SerializeDiagnosticResultAsync, GetResultLogInfo, result, CancellationToken))
using (var stream = await DirectStream.GetAsync(streamName, CancellationToken).ConfigureAwait(false))
{
using (var writer = new StreamObjectWriter(stream))
{
DiagnosticResultSerializer.Serialize(writer, result, CancellationToken);
}
await stream.FlushAsync(CancellationToken).ConfigureAwait(false);
}
}
private static async Task WriteToVersionAsync(
IPersistentStorage storage, string keyName, VersionStamp projectVersion, VersionStamp semanticVersion, CancellationToken cancellationToken)
{
using (var stream = SerializableBytes.CreateWritableStream())
using (var writer = new StreamObjectWriter(stream, cancellationToken: cancellationToken))
{
writer.WriteInt32(SerializationFormat);
projectVersion.WriteTo(writer);
semanticVersion.WriteTo(writer);
stream.Position = 0;
await storage.WriteStreamAsync(keyName, stream, cancellationToken).ConfigureAwait(false);
}
}
private void TestRoundTrip(Action <ObjectWriter> writeAction, Action <ObjectReader> readAction)
{
var stream = new MemoryStream();
var binder = new RecordingObjectBinder();
var writer = new StreamObjectWriter(stream, binder: binder);
writeAction(writer);
writer.Dispose();
stream.Position = 0;
using (var reader = new StreamObjectReader(stream, binder: binder))
{
readAction(reader);
}
}
private T RoundTrip <T>(T value, Action <ObjectWriter, T> writeAction, Func <ObjectReader, T> readAction)
{
var stream = new MemoryStream();
var binder = new RecordingObjectBinder();
var writer = new StreamObjectWriter(stream, binder: binder);
writeAction(writer, value);
writer.Dispose();
stream.Position = 0;
using (var reader = new StreamObjectReader(stream, binder: binder))
{
return((T)readAction(reader));
}
}
public static Checksum Create(string kind, IEnumerable <Checksum> checksums)
{
using (var stream = SerializableBytes.CreateWritableStream())
using (var writer = new StreamObjectWriter(stream))
{
writer.WriteString(kind);
foreach (var checksum in checksums)
{
checksum.WriteTo(writer);
}
return(Create(stream));
}
}
public static Checksum Create(string kind, ImmutableArray <byte> bytes)
{
using (var stream = SerializableBytes.CreateWritableStream())
using (var writer = new StreamObjectWriter(stream))
{
writer.WriteString(kind);
for (var i = 0; i < bytes.Length; i++)
{
writer.WriteByte(bytes[i]);
}
return(Create(stream));
}
}
public void VersionStamp_RoundTripText()
{
using (var writerStream = new MemoryStream())
using (var writer = new StreamObjectWriter(writerStream))
{
var versionStamp = VersionStamp.Create();
versionStamp.WriteTo(writer);
using (var readerStream = new MemoryStream(writerStream.ToArray()))
using (var reader = new StreamObjectReader(readerStream))
{
var deserializedVersionStamp = VersionStamp.ReadFrom(reader);
Assert.Equal(versionStamp, deserializedVersionStamp);
}
}
}
public async Task <bool> SerializeAsync(object documentOrProject, string key, ImmutableArray <DiagnosticData> items, CancellationToken cancellationToken)
{
using (var stream = SerializableBytes.CreateWritableStream())
using (var writer = new StreamObjectWriter(stream, cancellationToken: cancellationToken))
{
WriteTo(writer, items, cancellationToken);
var solution = GetSolution(documentOrProject);
var persistService = solution.Workspace.Services.GetService <IPersistentStorageService>();
using (var storage = persistService.GetStorage(solution))
{
stream.Position = 0;
return(await WriteStreamAsync(storage, documentOrProject, key, stream, cancellationToken).ConfigureAwait(false));
}
}
}
private T RoundTrip <T>(T value, Action <ObjectWriter, T> writeAction, Func <ObjectReader, T> readAction, bool recursive)
{
var stream = new MemoryStream();
var binder = new RecordingObjectBinder();
var writer = new StreamObjectWriter(stream, binder: binder, recursive: recursive);
writeAction(writer, value);
writer.Dispose();
stream.Position = 2;
Assert.Equal(recursive, StreamObjectReader.IsRecursive(stream));
stream.Position = 0;
using (var reader = StreamObjectReader.TryGetReader(stream, binder: binder))
{
return((T)readAction(reader));
}
}
public void TestSerialization()
{
var stream = new MemoryStream();
var bloomFilter = new BloomFilter(0.001, false, new[] { "Hello, World" });
using (var writer = new StreamObjectWriter(stream))
{
bloomFilter.WriteTo(writer);
}
stream.Position = 0;
using (var reader = new StreamObjectReader(stream))
{
var rehydratedFilter = BloomFilter.ReadFrom(reader);
Assert.True(bloomFilter.IsEquivalent(rehydratedFilter));
}
}
private static async Task <RemotableData> CloneAssetAsync(Serializer serializer, RemotableData asset)
{
using (var stream = SerializableBytes.CreateWritableStream())
using (var writer = new StreamObjectWriter(stream))
{
await asset.WriteObjectToAsync(writer, CancellationToken.None).ConfigureAwait(false);
stream.Position = 0;
using (var reader = new StreamObjectReader(stream))
{
var recovered = serializer.Deserialize <object>(asset.Kind, reader, CancellationToken.None);
var assetFromStorage = SolutionAsset.Create(serializer.CreateChecksum(recovered, CancellationToken.None), recovered, serializer);
Assert.Equal(asset.Checksum, assetFromStorage.Checksum);
return(assetFromStorage);
}
}
}
private void RoundTrip(Action <ObjectWriter> writeAction, Action <ObjectReader> readAction, bool recursive)
{
var stream = new MemoryStream();
var binder = new RecordingObjectBinder();
var writer = new StreamObjectWriter(stream, binder: binder, recursive: recursive);
writeAction(writer);
writer.Dispose();
stream.Position = 0;
Assert.Equal(recursive, StreamObjectReader.IsRecursive(stream));
stream.Position = 0;
using (var reader = new StreamObjectReader(stream, binder: binder))
{
readAction(reader);
}
}
protected static async Task <bool> SaveAsync <T>(
Document document, string persistenceName, string formatVersion, T data, CancellationToken cancellationToken) where T : AbstractPersistableState, IObjectWritable
{
Contract.Requires(!await document.IsForkedDocumentWithSyntaxChangesAsync(cancellationToken).ConfigureAwait(false));
var persistentStorageService = document.Project.Solution.Workspace.Services.GetService <IPersistentStorageService>();
// attempt to load from persisted state
using (var storage = persistentStorageService.GetStorage(document.Project.Solution))
using (var stream = SerializableBytes.CreateWritableStream())
using (var writer = new StreamObjectWriter(stream, cancellationToken: cancellationToken))
{
data.WriteVersion(writer, formatVersion);
data.WriteTo(writer);
stream.Position = 0;
return(await storage.WriteStreamAsync(document, persistenceName, stream, cancellationToken).ConfigureAwait(false));
}
}
private bool TrySaveIdentifierSetVersion(
EsentStorage.IdentifierLocationTableAccessor accessor, EsentStorage.Key key, VersionStamp version)
{
int identifierId;
if (!TryGetIdentifierSetVersionId(out identifierId))
{
return(false);
}
accessor.PrepareBatchOneInsert();
using (var stream = accessor.GetWriteStream(key, identifierId))
using (var writer = new StreamObjectWriter(stream))
{
version.WriteTo(writer);
}
accessor.FinishBatchOneInsert();
return(true);
}
public static async Task <T> GetValueAsync <T>(this ISolutionSynchronizationService service, Checksum checksum)
{
var syncService = (SolutionSynchronizationServiceFactory.Service)service;
var syncObject = service.GetRemotableData(checksum, CancellationToken.None);
using (var stream = SerializableBytes.CreateWritableStream())
using (var writer = new StreamObjectWriter(stream))
{
// serialize asset to bits
await syncObject.WriteObjectToAsync(writer, CancellationToken.None).ConfigureAwait(false);
stream.Position = 0;
using (var reader = new StreamObjectReader(stream))
{
// deserialize bits to object
var serializer = syncService.Serializer_TestOnly;
return(serializer.Deserialize <T>(syncObject.Kind, reader, CancellationToken.None));
}
}
}
public void TestObjectMapLimits()
{
using (var stream = new MemoryStream())
{
var instances = new List <TypeWithTwoMembers <int, string> >();
// We need enough items to exercise all sizes of ObjectRef
for (int i = 0; i < ushort.MaxValue + 1; i++)
{
instances.Add(new TypeWithTwoMembers <int, string>(i, i.ToString()));
}
var binder = new RecordingObjectBinder();
var writer = new StreamObjectWriter(stream, binder: binder);
// Write each instance twice. The second time around, they'll become ObjectRefs
for (int pass = 0; pass < 2; pass++)
{
foreach (var instance in instances)
{
writer.WriteValue(instance);
}
}
writer.Dispose();
stream.Position = 0;
using (var reader = new StreamObjectReader(stream, binder: binder))
{
for (int pass = 0; pass < 2; pass++)
{
foreach (var instance in instances)
{
var obj = reader.ReadValue();
Assert.NotNull(obj);
Assert.True(Equalish(obj, instance));
}
}
}
}
}
private TimeSpan TestReaderPerf(int iterations, bool recursive)
{
int id = 0;
var graph = ConstructGraph(ref id, 5, 3);
var stream = new MemoryStream();
var binder = new RecordingObjectBinder();
var writer = new StreamObjectWriter(stream, binder: binder, recursive: recursive);
writer.WriteValue(graph);
writer.Dispose();
var start = DateTime.Now;
for (int i = 0; i < iterations; i++)
{
stream.Position = 0;
var reader = new StreamObjectReader(stream, binder: binder);
var item = reader.ReadValue();
}
return(DateTime.Now - start);
}
