public T Deserialize <T>(WellKnownSynchronizationKind kind, ObjectReader reader, CancellationToken cancellationToken) { using (Logger.LogBlock(FunctionId.Serializer_Deserialize, kind.ToString(), cancellationToken)) { cancellationToken.ThrowIfCancellationRequested(); switch (kind) { case WellKnownSynchronizationKind.Null: return(default); case WellKnownSynchronizationKind.SolutionState: case WellKnownSynchronizationKind.ProjectState: case WellKnownSynchronizationKind.DocumentState: case WellKnownSynchronizationKind.Projects: case WellKnownSynchronizationKind.Documents: case WellKnownSynchronizationKind.TextDocuments: case WellKnownSynchronizationKind.ProjectReferences: case WellKnownSynchronizationKind.MetadataReferences: case WellKnownSynchronizationKind.AnalyzerReferences: return((T)(object)DeserializeChecksumWithChildren(reader, cancellationToken)); case WellKnownSynchronizationKind.SolutionAttributes: return((T)(object)SolutionInfo.SolutionAttributes.ReadFrom(reader)); case WellKnownSynchronizationKind.ProjectAttributes: return((T)(object)ProjectInfo.ProjectAttributes.ReadFrom(reader)); case WellKnownSynchronizationKind.DocumentAttributes: return((T)(object)DocumentInfo.DocumentAttributes.ReadFrom(reader)); case WellKnownSynchronizationKind.CompilationOptions: return((T)(object)DeserializeCompilationOptions(reader, cancellationToken)); case WellKnownSynchronizationKind.ParseOptions: return((T)(object)DeserializeParseOptions(reader, cancellationToken)); case WellKnownSynchronizationKind.ProjectReference: return((T)(object)DeserializeProjectReference(reader, cancellationToken)); case WellKnownSynchronizationKind.MetadataReference: return((T)(object)DeserializeMetadataReference(reader, cancellationToken)); case WellKnownSynchronizationKind.AnalyzerReference: return((T)(object)DeserializeAnalyzerReference(reader, cancellationToken)); case WellKnownSynchronizationKind.SourceText: return((T)(object)DeserializeSourceText(reader, cancellationToken)); case WellKnownSynchronizationKind.OptionSet: return((T)(object)DeserializeOptionSet(reader, cancellationToken)); default: throw ExceptionUtilities.UnexpectedValue(kind); } } }
private static Checksum CreateChecksumFromStreamWriter(WellKnownSynchronizationKind kind, Action <ObjectWriter, CancellationToken> writer) { using var stream = SerializableBytes.CreateWritableStream(); using var objectWriter = new ObjectWriter(stream); objectWriter.WriteInt32((int)kind); writer(objectWriter, CancellationToken.None); return(Checksum.Create(stream)); }
public static Checksum Create(WellKnownSynchronizationKind kind, IObjectWritable @object) { using var stream = SerializableBytes.CreateWritableStream(); using var objectWriter = new ObjectWriter(stream); objectWriter.WriteInt32((int)kind); @object.WriteTo(objectWriter); return(Create(stream)); }
public ChecksumObjectCollection(SerializationValidator validator, ChecksumCollection collection) { Checksum = collection.Checksum; Kind = collection.GetWellKnownSynchronizationKind(); // using .Result here since we don't want to convert all calls to this to async. // and none of ChecksumWithChildren actually use async Children = ImmutableArray.CreateRange(collection.Select(c => validator.GetValueAsync <T>(c).Result)); }
public static Checksum Create <T>(WellKnownSynchronizationKind kind, T value, ISerializerService serializer) { using (var stream = SerializableBytes.CreateWritableStream()) using (var objectWriter = new ObjectWriter(stream)) { objectWriter.WriteInt32((int)kind); serializer.Serialize(value, objectWriter, CancellationToken.None); return(Create(stream)); } }
public SolutionAsset(object?value, Checksum checksum, WellKnownSynchronizationKind kind) { // SolutionAsset is not allowed to hold strong references to SourceText. SerializableSourceText is used // instead to allow data to be released from process address space when it is also held in temporary // storage. // https://github.com/dotnet/roslyn/issues/43802 Contract.ThrowIfTrue(kind is WellKnownSynchronizationKind.SourceText); Checksum = checksum; Kind = kind; Value = value; }
public static Checksum Create(WellKnownSynchronizationKind kind, ImmutableArray <byte> bytes) { using var stream = SerializableBytes.CreateWritableStream(); using var writer = new ObjectWriter(stream); writer.WriteInt32((int)kind); for (var i = 0; i < bytes.Length; i++) { writer.WriteByte(bytes[i]); } return(Create(stream)); }
public static Checksum Create(WellKnownSynchronizationKind kind, IEnumerable <Checksum> checksums) { using var stream = SerializableBytes.CreateWritableStream(); using var writer = new ObjectWriter(stream); writer.WriteInt32((int)kind); foreach (var checksum in checksums) { checksum.WriteTo(writer); } return(Create(stream)); }
internal static async Task <T> VerifyAssetSerializationAsync <T>( IRemotableDataService service, Checksum checksum, WellKnownSynchronizationKind kind, Func <T, WellKnownSynchronizationKind, ISerializerService, RemotableData> assetGetter) { // re-create asset from object var syncService = (RemotableDataServiceFactory.Service)service; var syncObject = syncService.GetRemotableData_TestOnly(checksum, CancellationToken.None); var recoveredValue = await service.GetValueAsync <T>(checksum); var recreatedSyncObject = assetGetter(recoveredValue, kind, syncService.Serializer_TestOnly); // make sure original object and re-created object are same. SynchronizationObjectEqual(syncObject, recreatedSyncObject); return(recoveredValue); }
internal static async Task VerifyChecksumInServiceAsync(IRemotableDataService snapshotService, Checksum checksum, WellKnownSynchronizationKind kind) { Assert.NotNull(checksum); var service = (RemotableDataServiceFactory.Service)snapshotService; var otherObject = (await service.TestOnly_GetRemotableDataAsync(checksum, CancellationToken.None).ConfigureAwait(false)) !; ChecksumEqual(checksum, kind, otherObject.Checksum, otherObject.Kind); }
internal static async Task VerifyCollectionInService(IRemotableDataService snapshotService, ChecksumCollection checksums, int expectedCount, WellKnownSynchronizationKind expectedItemKind) { await VerifyChecksumInServiceAsync(snapshotService, checksums.Checksum, checksums.GetWellKnownSynchronizationKind()).ConfigureAwait(false); Assert.Equal(checksums.Count, expectedCount); foreach (var checksum in checksums) { await VerifyChecksumInServiceAsync(snapshotService, checksum, expectedItemKind).ConfigureAwait(false); } }
protected SolutionAsset(Checksum checksum, WellKnownSynchronizationKind kind) : base(checksum, kind) { }
public ChecksumWithChildren(WellKnownSynchronizationKind kind, params object[] children) { Checksum = CreateChecksum(kind, children); Children = children; }
internal static void VerifyChecksumInService(IRemotableDataService snapshotService, Checksum checksum, WellKnownSynchronizationKind kind) { Assert.NotNull(checksum); var service = (RemotableDataServiceFactory.Service)snapshotService; var otherObject = service.GetRemotableData_TestOnly(checksum, CancellationToken.None); ChecksumEqual(checksum, kind, otherObject.Checksum, otherObject.Kind); }
protected ChecksumCollection(WellKnownSynchronizationKind kind, Checksum[] checksums) : this(kind, (object[])checksums) { }
public static string ToStringFast(this WellKnownSynchronizationKind kind) => s_strings[(int)kind];
public SimpleCustomAsset(WellKnownSynchronizationKind kind, Action <ObjectWriter, CancellationToken> writer) : base(CreateChecksumFromStreamWriter(kind, writer), kind) { // unlike SolutionAsset which gets checksum from solution states, this one build one by itself. _writer = writer; }
public CustomAsset(Checksum checksum, WellKnownSynchronizationKind kind) : base(checksum, kind) { }
public SolutionAsset(object?value, Checksum checksum, WellKnownSynchronizationKind kind) { Checksum = checksum; Kind = kind; Value = value; }
private static Checksum CreateChecksum(WellKnownSynchronizationKind kind, object[] children) { // given children must be either Checksum or Checksums (collection of a checksum) return(Checksum.Create(kind, children.Select(c => c as Checksum ?? ((ChecksumCollection)c).Checksum))); }
protected ChecksumCollection(WellKnownSynchronizationKind kind, object[] checksums) : base(kind, checksums) { }
public T Deserialize <T>(WellKnownSynchronizationKind kind, ObjectReader reader, CancellationToken cancellationToken) { return(s_serializer.Deserialize <T>(kind, reader, cancellationToken)); }
internal static void VerifyCollectionInService(IRemotableDataService snapshotService, ChecksumCollection checksums, int expectedCount, WellKnownSynchronizationKind expectedItemKind) { VerifyChecksumInService(snapshotService, checksums.Checksum, checksums.GetWellKnownSynchronizationKind()); Assert.Equal(checksums.Count, expectedCount); foreach (var checksum in checksums) { VerifyChecksumInService(snapshotService, checksum, expectedItemKind); } }
public RemotableData(Checksum checksum, WellKnownSynchronizationKind kind) { Checksum = checksum; Kind = kind; }
internal static void ChecksumEqual(Checksum checksum1, WellKnownSynchronizationKind kind1, Checksum checksum2, WellKnownSynchronizationKind kind2) { Assert.Equal(checksum1, checksum2); Assert.Equal(kind1, kind2); }
internal static void VerifyChecksumInService(ISolutionSynchronizationService snapshotService, Checksum checksum, WellKnownSynchronizationKind kind) { Assert.NotNull(checksum); var otherObject = snapshotService.GetRemotableData(checksum, CancellationToken.None); ChecksumEqual(checksum, kind, otherObject.Checksum, otherObject.Kind); }