public object Deserialize( StreamReader streamReader, SerializationContext serializationContext, PropertyMetaData propertyMetaData = null) { var mess = new GenericCmdMessage(); mess.N3MessageType = (N3MessageType)streamReader.ReadInt32(); mess.Identity = streamReader.ReadIdentity(); mess.Unknown = streamReader.ReadByte(); mess.Temp1 = streamReader.ReadInt32(); mess.Count = streamReader.ReadInt32(); mess.Action = (GenericCmdAction)streamReader.ReadInt32(); mess.Temp4 = streamReader.ReadInt32(); mess.User = streamReader.ReadIdentity(); int len = 1; if (mess.Action == GenericCmdAction.UseItemOnItem) { len = 2; } mess.Target = new Identity[len]; for (int i = 0; i < mess.Target.Length; i++) { mess.Target[i] = streamReader.ReadIdentity(); } return mess; }
private static void WritePropertiesAsElements(SerializationContext serializationContext, MetaModelLibrary element, global::System.Xml.XmlWriter writer) { // FilePath if (!serializationContext.Result.Failed) { global::System.String propValue = element.FilePath; if (!serializationContext.Result.Failed) { if (!string.IsNullOrEmpty(propValue)) LanguageDSLSerializationHelper.Instance.WriteElementString(serializationContext, element, writer, "filePath", propValue); } } // Name if (!serializationContext.Result.Failed) { global::System.String propValue = element.Name; if (!serializationContext.Result.Failed) { if (!string.IsNullOrEmpty(propValue)) LanguageDSLSerializationHelper.Instance.WriteElementString(serializationContext, element, writer, "name", propValue); } } }
/// <summary> /// Initializes a new instance of the <see cref="SerializerEmitter"/> class for enum. /// </summary> /// <param name="context">A <see cref="SerializationContext"/>.</param> /// <param name="host">The host <see cref="ModuleBuilder"/>.</param> /// <param name="specification">The specification of the serializer.</param> /// <param name="isDebuggable">Set to <c>true</c> when <paramref name="host"/> is debuggable.</param> public SerializerEmitter( SerializationContext context, ModuleBuilder host, SerializerSpecification specification, bool isDebuggable ) : this( host, specification, typeof( EnumMessagePackSerializer<> ).MakeGenericType( specification.TargetType ), isDebuggable ) { Tracer.Emit.TraceEvent( Tracer.EventType.DefineType, Tracer.EventId.DefineType, "Create {0}", specification.SerializerTypeFullName ); this._defaultEnumSerializationMethod = context.EnumSerializationOptions.SerializationMethod; }
public override void Serialize(SerializationContext context) { base.Serialize(context); int target = (Owner != null) ? Owner.ServerIndex : -1; context.Write(target); }
/// <summary> /// Determines <see cref="EnumSerializationMethod"/> for the target. /// </summary> /// <param name="context">Context information.</param> /// <param name="enumType">The target enum type.</param> /// <param name="enumMemberSerializationMethod">The method argued by the member.</param> /// <returns>Determined <see cref="EnumSerializationMethod"/> for the target.</returns> public static EnumSerializationMethod DetermineEnumSerializationMethod( SerializationContext context, Type enumType, EnumMemberSerializationMethod enumMemberSerializationMethod ) { EnumSerializationMethod method = context.EnumSerializationMethod; switch ( enumMemberSerializationMethod ) { case EnumMemberSerializationMethod.ByName: { method = EnumSerializationMethod.ByName; break; } case EnumMemberSerializationMethod.ByUnderlyingValue: { method = EnumSerializationMethod.ByUnderlyingValue; break; } default: { var attributesOnType = enumType.GetCustomAttributes( typeof( MessagePackEnumAttribute ), false ); if ( attributesOnType.Length > 0 ) { // ReSharper disable once PossibleNullReferenceException method = ( attributesOnType[ 0 ] as MessagePackEnumAttribute ).SerializationMethod; } break; } } return method; }
public object Deserialize( StreamReader streamReader, SerializationContext serializationContext, PropertyMetaData propertyMetaData = null) { return streamReader.ReadInt16(); }
public void SaveToFile(string icsFilename) { var ctx = new SerializationContext(); var factory = new SerializerFactory(); var serializer = factory.Build(ical.GetType(), ctx) as IStringSerializer; var content = serializer.SerializeToString(ical); File.WriteAllText(icsFilename, content); }
public static void SerializeUnityObject(Stream stream, UnityObject obj, SerializationContext ctx) { var container = (List<UnityObject>)ctx.Context; var idx = container.Count; Basic.WriteInt32(stream, idx); container.Add(obj); }
public ByteArray(byte[] buffer, SerializationContext serializationContext) { this.serializationContext = serializationContext; memoryStream = new MemoryStream(buffer); ReloadStreams(); }
public ByteArray(MemoryStream ms, SerializationContext serializationContext) { this.serializationContext = serializationContext; memoryStream = ms; ReloadStreams(); }
public override void GetObjectData(SerializationContext output) { base.GetObjectData(output); output.WriteVersion(1); output.Write(ROM); }
/// <summary> /// Initializes a new instance of the <see cref="DynamicMethodEmittingContext"/> class. /// </summary> /// <param name="context">The serialization context.</param> /// <param name="targetType">Type of the serialization target.</param> /// <param name="emitterFactory"> /// The factory for <see cref="SerializerEmitter"/> to be used. /// </param> /// <param name="enumEmitterFactory"> /// The factory for <see cref="EnumSerializerEmitter"/> to be used. /// </param> public DynamicMethodEmittingContext( SerializationContext context, Type targetType, Func<SerializerEmitter> emitterFactory, Func<EnumSerializerEmitter> enumEmitterFactory ) : base( context, emitterFactory, enumEmitterFactory ) { this._context = ILConstruct.Argument( 0, typeof( SerializationContext ), "context" ); this.Reset( targetType, null ); }
internal static int Serialize(Guid value, SerializationContext context, bool lengthPrefix) { if (value == Guid.Empty) { if (lengthPrefix) { context.WriteByte(0); return 1; } return 0; } byte[] buffer = value.ToByteArray(); int len = 0; if (lengthPrefix) { context.WriteByte((byte)18); len = 1; } context.WriteByte(FieldLo << 3 | (int)WireType.Fixed64); context.WriteBlock(buffer, 0, 8); context.WriteByte(FieldHi << 3 | (int)WireType.Fixed64); context.WriteBlock(buffer, 8, 8); return len + 18; }
public object Deserialize( StreamReader streamReader, SerializationContext serializationContext, PropertyMetaData propertyMetaData = null) { return this.serializer.Deserialize(streamReader, serializationContext, propertyMetaData); }
public static int SerializeDecimal(decimal value, SerializationContext context, bool lengthPrefixed) { int[] bits = decimal.GetBits(value); ulong a = ((ulong)bits[1]) << 32, b = ((ulong)bits[0]) & 0xFFFFFFFFL; ulong low = a | b; uint high = (uint) bits[2]; uint signScale = (uint)(((bits[3] >> 15) & 0x01FE) | ((bits[3] >> 31) & 0x0001)); int len = 0; if (lengthPrefixed) { if (low != 0) len += 1 + SerializationContext.GetLength((long)low); if (high != 0) len += 1 + SerializationContext.GetLength((long)high); if (signScale!=0) len += 2; len = context.EncodeInt32(len); } if (low != 0) { context.WriteByte((FieldDecimalLow << 3) | (int)WireType.Variant); len += 1 + context.EncodeInt64((long)low); } if (high != 0) { // note encode as long to avoid high sign issues context.WriteByte((FieldDecimalHigh << 3) | (int)WireType.Variant); len += 1 + context.EncodeInt64((long)high); } if (signScale != 0) { context.WriteByte((FieldDecimalSignScale << 3) | (int)WireType.Variant); context.WriteByte((byte)signScale); len += 2; } return len; }
public object Deserialize( StreamReader streamReader, SerializationContext serializationContext, PropertyMetaData propertyMetaData = null) { var identityType = (IdentityType)streamReader.ReadInt32(); if (identityType != IdentityType.VendingMachine) { streamReader.Position = streamReader.Position - 4; return null; } var playfieldVendorInfo = new PlayfieldVendorInfo { Unknown1 = new Identity { Type = identityType, Instance = streamReader.ReadInt32() }, Unknown2 = streamReader.ReadInt32(), VendorCount = streamReader.ReadInt32(), FirstVendorId = streamReader.ReadInt32() }; return playfieldVendorInfo; }
public object ConvertTo(object item, Type sourceType, SerializationContext serializationContext) { // create a temp copy for processing List<IJsonTypeConverter> clonedList = new List<IJsonTypeConverter>(_converters); // loop through list until the last item, determining the source type along the way // process the last converter in the list and then remove it // repeat until all converters have been processed while (clonedList.Count > 0) { Type tempType = sourceType; for (int i = 0; i < clonedList.Count; i++) { if (i == clonedList.Count - 1) { // last element, process item = clonedList[i].ConvertTo(item, tempType, serializationContext); } else { // just determine the source type tempType = clonedList[i].GetSerializedType(tempType); } } clonedList.RemoveAt(clonedList.Count - 1); } return item; }
public void ExportSolution() { DDay.iCal.iCalendar iCal = new DDay.iCal.iCalendar(); var t = new DBManager(); t.initInputData(); t.initOutputData(); foreach(ScheduledTimeSlot[] solution in (t.solutions)) { for (int i = 0; i < solution.Length; i++) { Event evt = iCal.Create<Event>(); evt.Start = iCalDateTime.Today.AddHours((int)solution[i].timeSlot.StartHour).AddDays((int)(solution[i].timeSlot.Day)); evt.End = iCalDateTime.Today.AddHours((int)solution[i].timeSlot.EndHour).AddDays((int)(solution[i].timeSlot.Day)); evt.Summary = string.Join(", ", solution[i].groups.Select(g => g.name)); evt.Location = solution[i].room.nameOrNumber; } break; } ISerializationContext ctx = new SerializationContext(); ISerializerFactory factory = new DDay.iCal.Serialization.iCalendar.SerializerFactory(); // Get a serializer for our object IStringSerializer serializer = factory.Build(iCal.GetType(), ctx) as IStringSerializer; string output = serializer.SerializeToString(iCal); var bytes = Encoding.UTF8.GetBytes(output); File.WriteAllBytes("solution.ics", bytes); }
public LayoutInfo ConvertStringToLayoutInfo(string layoutInfo, Store store) { LayoutInfo lInfo = null; Microsoft.VisualStudio.Modeling.SerializationResult serializationResult = new Microsoft.VisualStudio.Modeling.SerializationResult(); DomainXmlSerializerDirectory directory = this.GetDirectory(store); System.Text.Encoding encoding = System.Text.Encoding.GetEncoding("ISO-8859-1"); Microsoft.VisualStudio.Modeling.SerializationContext serializationContext = new SerializationContext(directory, "", serializationResult); this.InitializeSerializationContext(store.DefaultPartition, serializationContext, false); DomainClassXmlSerializer rootSerializer = directory.GetSerializer(LayoutInfo.DomainClassId); using(System.Xml.XmlReader reader = System.Xml.XmlReader.Create(new System.IO.StringReader(layoutInfo)) ) { reader.Read(); // Move to the first node - will be the XmlDeclaration if there is one. serializationResult.Encoding = encoding; reader.MoveToContent(); lInfo = rootSerializer.TryCreateInstance(serializationContext, reader, store.DefaultPartition) as LayoutInfo; rootSerializer.Read(serializationContext, lInfo, reader); } return lInfo; }
// GET: Calendar public ActionResult Index() { foreach (var r in Request.Params.AllKeys) { System.Diagnostics.Debug.WriteLine(r + " = " + Request.Params[r]); } var iCal = new iCalendar(); Event evt = iCal.Create<Event>(); evt.Start = iCalDateTime.Today.AddHours(8); evt.End = evt.Start.AddHours(18); // This also sets the duration evt.Description = "The event description"; evt.Location = "Event location"; evt.Summary = "18 hour event summary"; evt = iCal.Create<Event>(); evt.Start = iCalDateTime.Today.AddDays(5); evt.End = evt.Start.AddDays(1); evt.IsAllDay = true; evt.Summary = "All-day event"; ISerializationContext ctx = new SerializationContext(); ISerializerFactory factory = new DDay.iCal.Serialization.iCalendar.SerializerFactory(); IStringSerializer serializer = factory.Build(iCal.GetType(), ctx) as IStringSerializer; string output = serializer.SerializeToString(iCal); var bytes = System.Text.Encoding.UTF8.GetBytes(output); return File(bytes, "text/calendar"); }
public void Callback(object value, TypeModel.CallbackType callbackType, SerializationContext context) { IProtoTypeSerializer protoTypeSerializer = this.Tail as IProtoTypeSerializer; if (protoTypeSerializer != null) { protoTypeSerializer.Callback(value, callbackType, context); } }
public void Serialize( StreamWriter streamWriter, SerializationContext serializationContext, object value, PropertyMetaData propertyMetaData = null) { streamWriter.WriteInt16((short)value); }
public static UnityObject DeserializeUnityObject(Stream stream, SerializationContext ctx) { var container = (List<UnityObject>)ctx.Context; int idx = Basic.ReadInt32(stream); if (idx < 0 || idx >= container.Count) return null; return container[idx]; }
public object ConvertFrom(object item, SerializationContext serializationContext) { foreach (IJsonTypeConverter converter in _converters) { item = converter.ConvertFrom(item, serializationContext); } return item; }
/// <summary> /// Initialize the serialization context on load / save /// </summary> /// <remarks>We need to supply a model bus for ModelBusReference deserialization to work</remarks> protected override void InitializeSerializationContext(Partition partition, SerializationContext serializationContext, bool isLoading) { Debug.Assert(partition != null, "partition should not be null"); Debug.Assert(serializationContext != null, "serializationContext should not be null"); IModelBus modelbus = partition.Store.GetService(typeof(SModelBus)) as IModelBus; serializationContext[Microsoft.VisualStudio.Modeling.Integration.ModelBusReferencePropertySerializer.ModelBusLoadContextKey] = modelbus; }
public object Deserialize( StreamReader streamReader, SerializationContext serializationContext, PropertyMetaData propertyMetaData = null) { var address = new IPAddress(streamReader.ReadBytes(4)); return address; }
public AssemblyBuilderCodeGenerationContext( SerializationContext context, AssemblyBuilder assemblyBuilder ) { this._context = context; this._assemblyBuilder = assemblyBuilder; DefaultSerializationMethodGeneratorManager.SetUpAssemblyBuilderAttributes( assemblyBuilder, false ); this._generatorManager = SerializationMethodGeneratorManager.Get( assemblyBuilder ); }
public override object ConvertTo(object item, Type sourceType, SerializationContext serializationContext) { string typeNameOrAlias = (string)item; Type typeResult = serializationContext.TypeAliases[typeNameOrAlias]; if (typeResult == null) typeResult = Type.GetType(typeNameOrAlias); return typeResult; }
internal SerializerHelper(Type t, SerializationContext context, TextWriter writer) : base(writer, !context.IsCompact) { _serializedType = t; _context = context; //_writer = writer; _refs = new Dictionary<object, ReferenceInfo>(new ReferenceEqualityComparer<object>()); }
public void Ctor() { var c = new MockClientConnection (new MockConnectionProvider (MockProtocol.Instance)); var context = new SerializationContext (c, MockProtocol.Instance, new TypeMap()); Assert.AreSame (c, context.Connection); Assert.AreSame (MockProtocol.Instance, context.Protocol); }
private static T UnpackCore <T>(Unpacker source, SerializationContext context) { return(MessagePackSerializer.Create <T>(context).UnpackFrom(source)); }
public MessagePackHubProtocol(IOptions <MessagePackHubProtocolOptions> options) { SerializationContext = options.Value.SerializationContext; }
internal OrdinaryDictionarySerializer(SerializationContext ownerContext) : base(ownerContext) { }
public JsonValue Serialize(SerializationContext context) { var schema = (JsonSchema)context.Source !; return(schema.ToJson(context.RootSerializer)); }
public void Deserialize(BufferReader reader, ref UnmanagedArray <T> target, SerializationContext context) { // we already read the size in PrepareDeserializationTarget if (target.Length > 0) { reader.Read((void *)target.data, target.Length); } }
public void PrepareDeserializationTarget(BufferReader reader, ref UnmanagedArray <T> target, SerializationContext context) { var size = reader.ReadInt32(); if (target == null) { target = new UnmanagedArray <T>(size); } else { target.Resize(size); } }
/// <summary> /// Serialize an instance of type <typeparamref name="T"/> to a byte array /// in Protobuf format. The serialized data is preceeded by: /// 1. A "magic byte" (1 byte) that identifies this as a message with /// Confluent Platform framing. /// 2. The id of the schema as registered in Confluent's Schema Registry /// (4 bytes, network byte order). /// 3. An size-prefixed array of indices that identify the specific message /// type in the schema (a given schema can contain many message types /// and they can be nested). Size and indices are unsigned varints. The /// common case where the message type is the first message in the schema /// (i.e. index data would be [1,0]) is encoded as simply a single 0 byte /// as an optimization. /// This call may block or throw on first use for a particular topic during /// schema registration / verification. /// </summary> /// <param name="value"> /// The value to serialize. /// </param> /// <param name="context"> /// Context relevant to the serialize operation. /// </param> /// <returns> /// A <see cref="System.Threading.Tasks.Task" /> that completes with /// <paramref name="value" /> serialized as a byte array. /// </returns> public async Task <byte[]> SerializeAsync(T value, SerializationContext context) { if (value == null) { return(null); } try { if (this.indexArray == null) { this.indexArray = createIndexArray(value.Descriptor, useDeprecatedFormat); } string fullname = value.Descriptor.FullName; await serializeMutex.WaitAsync().ConfigureAwait(continueOnCapturedContext: false); try { string subject = this.subjectNameStrategy != null // use the subject name strategy specified in the serializer config if available. ? this.subjectNameStrategy(context, fullname) // else fall back to the deprecated config from (or default as currently supplied by) SchemaRegistry. : context.Component == MessageComponentType.Key ? schemaRegistryClient.ConstructKeySubjectName(context.Topic, fullname) : schemaRegistryClient.ConstructValueSubjectName(context.Topic, fullname); if (!subjectsRegistered.Contains(subject)) { if (useLatestVersion) { var latestSchema = await schemaRegistryClient.GetLatestSchemaAsync(subject) .ConfigureAwait(continueOnCapturedContext: false); schemaId = latestSchema.Id; } else { var references = await RegisterOrGetReferences(value.Descriptor.File, context, autoRegisterSchema, skipKnownTypes) .ConfigureAwait(continueOnCapturedContext: false); // first usage: register/get schema to check compatibility schemaId = autoRegisterSchema ? await schemaRegistryClient.RegisterSchemaAsync(subject, new Schema(value.Descriptor.File.SerializedData.ToBase64(), references, SchemaType.Protobuf), normalizeSchemas) .ConfigureAwait(continueOnCapturedContext: false) : await schemaRegistryClient.GetSchemaIdAsync(subject, new Schema(value.Descriptor.File.SerializedData.ToBase64(), references, SchemaType.Protobuf), normalizeSchemas) .ConfigureAwait(continueOnCapturedContext: false); // note: different values for schemaId should never be seen here. // TODO: but fail fast may be better here. } subjectsRegistered.Add(subject); } } finally { serializeMutex.Release(); } using (var stream = new MemoryStream(initialBufferSize)) using (var writer = new BinaryWriter(stream)) { stream.WriteByte(Constants.MagicByte); writer.Write(IPAddress.HostToNetworkOrder(schemaId.Value)); writer.Write(this.indexArray); value.WriteTo(stream); return(stream.ToArray()); } } catch (AggregateException e) { throw e.InnerException; } }
public JsonValue Serialize(SerializationContext context) { var guid = (Guid)context.Source !; return(guid.ToString()); }
public System_Collections_Generic_Queue_1MessagePackSerializer(SerializationContext ownerContext) : base(ownerContext) { this._itemSerializer = ownerContext.GetSerializer <TItem>(); }
/// <summary> /// Create a new <see cref="MsgPackSerializer"/> instance. /// </summary> /// <param name="context">The serialization context information for internal serialization logic.</param> public MsgPackSerializer(SerializationContext context) { _context = context ?? throw new ArgumentNullException(nameof(context)); }
public T Deserialize(ReadOnlySpan <byte> data, bool isNull, SerializationContext context) { return(JsonConvert.DeserializeObject <T>( Deserializers.Utf8.Deserialize(data, isNull, context), Settings)); }
public OrganizerSerializer(SerializationContext ctx) : base(ctx) { }
public void PrepareCloningTarget(UnmanagedArray <T> instance, ref UnmanagedArray <T> target, SerializationContext context) { if (target == null) { target = new UnmanagedArray <T>(instance.Length); } else { target.Resize(instance.Length); } }
public void Callback(object value, TypeModel.CallbackType callbackType, SerializationContext context) { if (callbacks != null) InvokeCallback(callbacks[callbackType], value, context); IProtoTypeSerializer ser = (IProtoTypeSerializer)GetMoreSpecificSerializer(value); if (ser != null) ser.Callback(value, callbackType, context); }
/// <summary> /// This method loads the DSL view model with the items in the artifact's C-Model. /// </summary> internal void ReloadModel(EntityDesignerViewModel viewModel) { var diagram = viewModel.GetDiagram(); if (diagram == null) { // empty DSL diagram return; } // get our artifact var artifact = EditingContextManager.GetArtifact(viewModel.EditingContext) as EntityDesignArtifact; Debug.Assert(artifact != null); var serializationResult = new SerializationResult(); var serializationContext = new SerializationContext(GetDirectory(viewModel.Store), artifact.Uri.LocalPath, serializationResult); var transactionContext = new TransactionContext(); transactionContext.Add(SerializationContext.TransactionContextKey, serializationContext); var workaroundFixSerializationTransactionValue = false; if (viewModel.Store.PropertyBag.ContainsKey("WorkaroundFixSerializationTransaction")) { workaroundFixSerializationTransactionValue = (bool)viewModel.Store.PropertyBag["WorkaroundFixSerializationTransaction"]; } try { // To fix performance issue during reload, we turn-off layout during "serialization". viewModel.Store.PropertyBag["WorkaroundFixSerializationTransaction"] = true; using (var t = viewModel.Store.TransactionManager.BeginTransaction("ReloadModel", true, transactionContext)) { if (artifact.ConceptualModel() == null) { return; } DesignerModel.Diagram diagramModel = null; // If DiagramId is not string empty, try to get the diagram from the artifact. // There is a situation where we could not find the diagram given an ID (for example: EDMX Model's Diagram that is created by VS before SQL 11; // In that case, we assign temporary ID to the diagram and a new ID will be generated every time the model is reloaded.) // We could safely choose the first diagram since multiple diagrams feature didn't exist in VS prior to SQL11 release. if (!string.IsNullOrEmpty(diagram.DiagramId)) { diagramModel = artifact.DesignerInfo.Diagrams.GetDiagram(diagram.DiagramId); } if (diagramModel == null) { diagramModel = artifact.DesignerInfo.Diagrams.FirstDiagram; } if (diagramModel != null) { // Re-establish the xref between Escher conceptual model and DSL root model. // and between Escher Diagram model and DSL diagram model. Debug.Assert(viewModel.ModelXRef != null, "Why ModelXRef is null?"); if (viewModel.ModelXRef != null) { viewModel.ModelXRef.Add(artifact.ConceptualModel(), viewModel, viewModel.EditingContext); viewModel.ModelXRef.Add(diagramModel, diagram, viewModel.EditingContext); ModelTranslatorContextItem.GetEntityModelTranslator(viewModel.EditingContext) .TranslateModelToDslModel(diagramModel, viewModel.Partition); } } if (t.IsActive) { t.Commit(); } } } finally { viewModel.Store.PropertyBag["WorkaroundFixSerializationTransaction"] = workaroundFixSerializationTransactionValue; } }
public ArrayFormatObjectExpressionMessagePackSerializer(SerializationContext context, SerializingMember[] members) : base(context, members) { }
public BasicObjectWrapper(SerializationContext context) { this.context = context; }
/// <remarks> /// note: protobuf does not support circular file references, so this possibility isn't considered. /// </remarks> private async Task <List <SchemaReference> > RegisterOrGetReferences(FileDescriptor fd, SerializationContext context, bool autoRegisterSchema, bool skipKnownTypes) { var tasks = new List <Task <SchemaReference> >(); for (int i = 0; i < fd.Dependencies.Count; ++i) { FileDescriptor fileDescriptor = fd.Dependencies[i]; if (skipKnownTypes && fileDescriptor.Name.StartsWith("google/protobuf/")) { continue; } Func <FileDescriptor, Task <SchemaReference> > t = async(FileDescriptor dependency) => { var dependencyReferences = await RegisterOrGetReferences(dependency, context, autoRegisterSchema, skipKnownTypes).ConfigureAwait(continueOnCapturedContext: false); var subject = referenceSubjectNameStrategy(context, dependency.Name); var schema = new Schema(dependency.SerializedData.ToBase64(), dependencyReferences, SchemaType.Protobuf); var schemaId = autoRegisterSchema ? await schemaRegistryClient.RegisterSchemaAsync(subject, schema, normalizeSchemas).ConfigureAwait(continueOnCapturedContext: false) : await schemaRegistryClient.GetSchemaIdAsync(subject, schema, normalizeSchemas).ConfigureAwait(continueOnCapturedContext: false); var registeredDependentSchema = await schemaRegistryClient.LookupSchemaAsync(subject, schema, true, normalizeSchemas).ConfigureAwait(continueOnCapturedContext: false); return(new SchemaReference(dependency.Name, subject, registeredDependentSchema.Version)); }; tasks.Add(t(fileDescriptor)); } await Task.WhenAll(tasks.ToArray()).ConfigureAwait(continueOnCapturedContext: false); return(tasks.Select(t => t.Result).ToList()); }
/// <summary> /// Deserializes a <typeparamref name="TMessage"/> value from a byte array. /// </summary> /// <param name="data">The data to deserialize.</param> /// <param name="isNull">is the data or value null</param> /// <param name="context">The serialization context</param> /// <returns><paramref name="data" /> deserialized to a <typeparamref name="TMessage"/> (or null if data is null).</returns> public TMessage Deserialize(ReadOnlySpan <byte> data, bool isNull, SerializationContext context) { if (isNull || data == null) { return(default);
public Task <T> DeserializeAsync(ReadOnlyMemory <byte> data, bool isNull, SerializationContext context) { if (isNull) { return(default);
public AttendeeSerializer(SerializationContext ctx) : base(ctx) { }
void IProtoTypeSerializer.Callback(object value, ProtoBuf.Meta.TypeModel.CallbackType callbackType, SerializationContext context) { }
public FluentdEmitter(Stream stream) { this.serializationContext = new SerializationContext(PackerCompatibilityOptions.PackBinaryAsRaw); this.serializationContext.Serializers.Register(new OrdinaryDictionarySerializer(this.serializationContext)); this.packer = Packer.Create(stream); }
public void Clear(ref UnmanagedArray <T> target, SerializationContext context) { // nothing to clear since T is a pure value type }
public System_VersionMessagePackSerializer(SerializationContext ownerContext) : base(ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom) { }
public void Clone(UnmanagedArray <T> instance, ref UnmanagedArray <T> target, SerializationContext context) { Buffer.MemoryCopy((void *)instance.data, (void *)target.data, target.length, instance.Length); }
public byte[] Serialize(T data, SerializationContext context) { return(data.ToByteArray()); }
public void Callback(object value, TypeModel.CallbackType callbackType, SerializationContext context) { }
public void ExceptionSerializer_UnknownException() { var expected = GetNewException(); var knowsException = new ILBasedExceptionSerializer(this.serializerGenerator, new TypeSerializer(new CachedTypeResolver())); var writer = new SerializationContext(this.environment.SerializationManager) { StreamWriter = new BinaryTokenStreamWriter() }; knowsException.Serialize(expected, writer, null); // Deep copies should be reference-equal. var copyContext = new SerializationContext(this.environment.SerializationManager); Assert.Equal(expected, knowsException.DeepCopy(expected, copyContext), ReferenceEqualsComparer.Instance); // Create a deserializer which doesn't know about the expected exception type. var reader = new DeserializationContext(this.environment.SerializationManager) { StreamReader = new BinaryTokenStreamReader(writer.StreamWriter.ToByteArray()) }; // Ensure that the deserialized object has the fallback type. var doesNotKnowException = new ILBasedExceptionSerializer(this.serializerGenerator, new TestTypeSerializer(new CachedTypeResolver())); var untypedActual = doesNotKnowException.Deserialize(null, reader); Assert.IsType <RemoteNonDeserializableException>(untypedActual); // Ensure that the original type name is preserved correctly. var actualDeserialized = (RemoteNonDeserializableException)untypedActual; Assert.Equal(RuntimeTypeNameFormatter.Format(typeof(ILExceptionSerializerTestException)), actualDeserialized.OriginalTypeName); // Re-serialize the deserialized object using the serializer which does not have access to the original type. writer = new SerializationContext(this.environment.SerializationManager) { StreamWriter = new BinaryTokenStreamWriter() }; doesNotKnowException.Serialize(untypedActual, writer, null); reader = new DeserializationContext(this.environment.SerializationManager) { StreamReader = new BinaryTokenStreamReader(writer.StreamWriter.ToByteArray()) }; // Deserialize the round-tripped object and verify that it has the original type and all properties are // correctly. untypedActual = knowsException.Deserialize(null, reader); Assert.IsType <ILExceptionSerializerTestException>(untypedActual); var actual = (ILExceptionSerializerTestException)untypedActual; Assert.Equal(expected.BaseField.Value, actual.BaseField.Value, StringComparer.Ordinal); Assert.Equal(expected.SubClassField, actual.SubClassField, StringComparer.Ordinal); Assert.Equal(expected.OtherField.Value, actual.OtherField.Value, StringComparer.Ordinal); // Check for referential equality in the two fields which happened to be reference-equals. Assert.Equal(actual.BaseField, actual.OtherField, ReferenceEqualsComparer.Instance); }
public System_Numerics_BigIntegerMessagePackSerializer(SerializationContext ownerContext) : base(ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom) { }