public LongRunningOperation(OperationGroup operationGroup, Operation operation, BuildContext context) : base(context) { Debug.Assert(operation.IsLongRunning); var clientClass = context.Library.FindClient(operationGroup); Debug.Assert(clientClass != null, "clientClass != null, LROs should be disabled when public clients are disables"); DefaultName = clientClass.RestClient.ClientPrefix + operation.CSharpName() + "Operation"; FinalStateVia = operation.LongRunningFinalStateVia switch { "azure-async-operation" => OperationFinalStateVia.AzureAsyncOperation, "location" => OperationFinalStateVia.Location, "original-uri" => OperationFinalStateVia.OriginalUri, null => OperationFinalStateVia.Location, _ => throw new ArgumentException($"Unknown final-state-via value: {operation.LongRunningFinalStateVia}") }; var finalResponse = operation.LongRunningFinalResponse; Schema?finalResponseSchema = finalResponse.ResponseSchema; if (finalResponseSchema != null) { ResultType = TypeFactory.GetOutputType(context.TypeFactory.CreateType(finalResponseSchema, false)); ResultSerialization = new SerializationBuilder().Build(finalResponse.HttpResponse.KnownMediaType, finalResponseSchema, ResultType); } else { ResultType = typeof(Response); } Description = BuilderHelpers.EscapeXmlDescription(operation.Language.Default.Description); DefaultAccessibility = clientClass.Declaration.Accessibility; }
public ObjectType(ObjectSchema objectSchema, BuildContext context) : base(context) { _objectSchema = objectSchema; _typeFactory = context.TypeFactory; _serializationBuilder = new SerializationBuilder(); var hasUsage = objectSchema.Usage.Any() && !objectSchema.IsExceptionOnly; DefaultAccessibility = objectSchema.Extensions?.Accessibility ?? (hasUsage ? "public" : "internal"); Description = BuilderHelpers.CreateDescription(objectSchema); DefaultName = objectSchema.CSharpName(); DefaultNamespace = objectSchema.Extensions?.Namespace ?? $"{context.DefaultNamespace}.Models"; _sourceTypeMapping = context.SourceInputModel.CreateForModel(ExistingType); }
public RestClient(OperationGroup operationGroup, BuildContext context) : base(context) { _operationGroup = operationGroup; _context = context; _parameters = operationGroup.Operations .SelectMany(op => op.Parameters.Concat(op.Requests.SelectMany(r => r.Parameters))) .Where(p => p.Implementation == ImplementationLocation.Client) .Distinct() .ToDictionary(p => p.Language.Default.Name, BuildClientParameter); _serializationBuilder = new SerializationBuilder(); Parameters = OrderParameters(_parameters.Values); var mainClient = context.Library.FindClient(operationGroup); ClientPrefix = GetClientPrefix(mainClient?.Declaration.Name ?? operationGroup.Language.Default.Name); DefaultName = ClientPrefix + RestClientSuffix; Description = ""; }
/// <summary> /// Add Serialization services /// </summary> /// <param name="services">ServicesCollection</param> /// <param name="builderAction">Action to handle the serialization builder</param> /// <returns>ServicesCollection</returns> /// <exception cref="ArgumentNullException"></exception> public static SerializationBuilder AddSerialization( this IServiceCollection services, Action <SerializationBuilder> builderAction) { if (services == null) { throw new ArgumentNullException(nameof(services)); } if (builderAction == null) { throw new ArgumentNullException(nameof(builderAction)); } var builder = new SerializationBuilder(services); builderAction.Invoke(builder); builder.Build(); return(builder); }
static void Main(string[] args) { /* * // Test reading of VPP * Stream stream = File.OpenRead("patch.vpp_pc"); * PackageFile package = new PackageFile(); * package.Read(stream); * stream.Close(); */ /* * // Test reading of LeStrings * Stream stream = File.OpenRead("static_US.le_strings"); * StringsFile = new LeStringsFile(); * StringsFile.Read(stream); * stream.Close(); * Console.WriteLine(StringsFile.Strings["DROP_DESTINY".KeyCRC32()]); */ /* * // Check if my created vpp is correct :) * Stream stream; * * stream = File.OpenRead("patch.vpp_pc"); * PackageFile patch = new PackageFile(); * patch.Read(stream); * long patchSize = stream.Length; * stream.Close(); * * stream = File.OpenRead("patch_test.vpp_pc"); * PackageFile test = new PackageFile(); * test.Read(stream); * long testSize = stream.Length; * stream.Close(); * * SortedDictionary<string, long> patch_sizes = GetSizes(patch, patchSize); * SortedDictionary<string, long> test_sizes = GetSizes(test, testSize); * * foreach (string name in patch_sizes.Keys) * { * if (test_sizes.ContainsKey(name) == false) * { * Console.WriteLine("{0} is missing", name); * continue; * } * * if (test_sizes[name] != patch_sizes[name]) * { * Console.WriteLine("{0}: {1} vs {2}", name, patch_sizes[name], test_sizes[name]); * } * } */ /* * // Test reading of vint_doc * foreach (string path in Directory.GetFiles(".", "*.vint_doc")) * { * FileStream stream = File.OpenRead(path); * VintFile vintFile = new VintFile(); * vintFile.Read(stream); * stream.Close(); * } */ foreach (string path in Directory.GetFiles("extracted\\common", "*.xtbl")) { Stream stream = File.OpenRead(path); SerializationBuilder builder = new SerializationBuilder(); builder.ReadXmlTable(stream); stream.Close(); } }
static void Main(string[] args) { var Arguments = new ProgramArguments(); args.AsParametersTo(Arguments); Console.WriteLine("Assembly: " + Arguments.Assembly.FullName); if (Arguments.Assembly == null) { return; } if (!Arguments.Assembly.Exists) { return; } Console.WriteLine(new { Assembly = Arguments.Assembly.FullName, Arguments.TargetType }.ToString()); #region ensure referenced libraries are provided foreach (var reference in Assembly.GetExecutingAssembly().GetReferencedAssemblies()) { var ra = Assembly.Load(reference); if (new FileInfo(ra.Location).Directory.FullName == new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.FullName) { if (new FileInfo(ra.Location).FullName != new FileInfo(new FileInfo(ra.Location).Name).FullName) { Console.WriteLine("ensure: " + reference); // delete old files if (new FileInfo(new FileInfo(ra.Location).Name).Exists) { new FileInfo(new FileInfo(ra.Location).Name).Delete(); } File.Copy(new FileInfo(ra.Location).FullName, new FileInfo(new FileInfo(ra.Location).Name).FullName); } } } #endregion var server_EntryPoint = default(MethodInfo); ConsoleRouterEmitter.BuildServer(Arguments, n => server_EntryPoint = n); // business speak: // this is the tool to make multiplayer happen // it should not be bundled with jsc package until it is mature (2009 summer?) Func <byte> BinaryReader_ReadByte = new BinaryReader(new MemoryStream()).ReadByte; Func <char> BinaryReader_ReadChar = new BinaryReader(new MemoryStream()).ReadChar; Func <int> BinaryReader_ReadInt32 = new BinaryReader(new MemoryStream()).ReadInt32; Action <byte> BinaryWriter_WriteByte = new BinaryWriter(new MemoryStream()).Write; Action <int> BinaryWriter_WriteInt32 = new BinaryWriter(new MemoryStream()).Write; Action <char> BinaryWriter_WriteChar = new BinaryWriter(new MemoryStream()).Write; // http://davidhayden.com/blog/dave/archive/2006/02/05/2791.aspx // http://groups.google.com/group/microsoft.public.dotnet.languages.csharp/browse_thread/thread/1a591da28ec3f02e/23817db409dfbc84 // http://stackoverflow.com/questions/193875/assembly-not-saving-correctly var TargetAssembly = Assembly.LoadFile(Arguments.Assembly.FullName); var TargetType = TargetAssembly.GetType(Arguments.TargetType); var PeerAssemblyName = new AssemblyName(Path.GetFileNameWithoutExtension(TargetAssembly.Location) + "Peer"); var PeerAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(PeerAssemblyName, AssemblyBuilderAccess.RunAndSave); var m = PeerAssembly.DefineDynamicModule( PeerAssemblyName.Name, PeerAssemblyName.Name + ".exe" //"Layer1Module1.mod" ); //var t = m.DefineType("``.*`MyType1", TypeAttributes.Public); var t = m.DefineType(PeerAssemblyName.Name + ".ServerAndPeer", TypeAttributes.Public); t.SetCustomAttribute( new CustomAttributeBuilder(typeof(ScriptCoreLib.ScriptAttribute).GetConstructor(new Type[0]), new object[0]) ); var Field_Context = t.DefineField("Context", TargetType, FieldAttributes.Public | FieldAttributes.InitOnly); var Field_CurrentWriter = t.DefineField("CurrentWriter", typeof(BinaryWriter), FieldAttributes.Public); var ctor = t.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[0]); var ctor_il = ctor.GetILGenerator(); // we are going to overload those events var Events = TargetType.GetFields().Where(k => k.FieldType.BaseType == typeof(MulticastDelegate)).ToArray(); Action <string> WriteLine = text => { ctor_il.EmitWriteLine(text); Console.WriteLine(text); }; ctor_il.Emit(OpCodes.Ldarg_0); ctor_il.Emit(OpCodes.Newobj, TargetType.GetConstructor(Type.EmptyTypes)); ctor_il.Emit(OpCodes.Stfld, Field_Context); WriteLine("the following events should be overridden:"); var EmitClassDeserializer = SerializationBuilder.GetEmitClassDeserializer(t); var EmitClassSerializer = SerializationBuilder.GetEmitClassSerializer(t); var Fields_Event = new List <FieldBuilder>(); { var EventIndex = 0; foreach (var k in Events) { EventIndex++; WriteLine("#" + EventIndex + " " + k.Name); var Field_Event = t.DefineField("`" + k.Name, k.FieldType, FieldAttributes.InitOnly); Fields_Event.Add(Field_Event); #region preserve original implementation ctor_il.Emit(OpCodes.Ldarg_0); ctor_il.Emit(OpCodes.Ldarg_0); ctor_il.Emit(OpCodes.Ldfld, Field_Context); ctor_il.Emit(OpCodes.Ldfld, k); ctor_il.Emit(OpCodes.Stfld, Field_Event); #endregion var k_Invoke = k.FieldType.GetMethod("Invoke"); var Method_AtEvent = t.DefineMethod("``" + k.Name, MethodAttributes.Public, CallingConventions.HasThis, k_Invoke.ReturnType, k_Invoke.GetParameters().Select(kk => kk.ParameterType).ToArray()); var Method_AtEvent_il = Method_AtEvent.GetILGenerator(); //Method_AtEvent_il.EmitWriteLine(k.Name + " to network"); #region to network Method_AtEvent_il.Emit(OpCodes.Ldarg_0); Method_AtEvent_il.Emit(OpCodes.Ldfld, Field_CurrentWriter); Method_AtEvent_il.Emit(OpCodes.Ldc_I4, EventIndex); Method_AtEvent_il.EmitCall(OpCodes.Callvirt, BinaryWriter_WriteByte.Method, null); foreach (var p in k_Invoke.GetParameters().Skip(1)) { if (p.ParameterType == typeof(int)) { Method_AtEvent_il.Emit(OpCodes.Ldarg_0); Method_AtEvent_il.Emit(OpCodes.Ldfld, Field_CurrentWriter); Method_AtEvent_il.Emit(OpCodes.Ldarg_S, (byte)(p.Position + 1)); Method_AtEvent_il.EmitCall(BinaryWriter_WriteInt32); } else if (p.ParameterType == typeof(char)) { Method_AtEvent_il.Emit(OpCodes.Ldarg_0); Method_AtEvent_il.Emit(OpCodes.Ldfld, Field_CurrentWriter); Method_AtEvent_il.Emit(OpCodes.Ldarg_S, (byte)(p.Position + 1)); Method_AtEvent_il.EmitCall(BinaryWriter_WriteChar); } else if (p.ParameterType == typeof(byte)) { Method_AtEvent_il.Emit(OpCodes.Ldarg_0); Method_AtEvent_il.Emit(OpCodes.Ldfld, Field_CurrentWriter); Method_AtEvent_il.Emit(OpCodes.Ldarg_S, (byte)(p.Position + 1)); Method_AtEvent_il.EmitCall(BinaryWriter_WriteByte); } else if (p.ParameterType.IsClass) { // we are about to serialize this class // if null we shall skip to serialize it // als we should add stack to prevent circular references Method_AtEvent_il.Emit(OpCodes.Ldarg_0); Method_AtEvent_il.Emit(OpCodes.Ldarg_0); Method_AtEvent_il.Emit(OpCodes.Ldfld, Field_CurrentWriter); Method_AtEvent_il.Emit(OpCodes.Ldarg_S, (byte)(p.Position + 1)); Method_AtEvent_il.EmitCall(OpCodes.Call, EmitClassSerializer(p.ParameterType), null); } else { throw new NotSupportedException(p.ParameterType.FullName); } } #endregion //Method_AtEvent_il.EmitWriteLine(k.Name + " to local"); #region this.AtEvent(arguments[...]) Method_AtEvent_il.Emit(OpCodes.Ldarg_0); Method_AtEvent_il.Emit(OpCodes.Ldfld, Field_Event); var pi = 1; foreach (var p in k_Invoke.GetParameters()) { Method_AtEvent_il.Emit(OpCodes.Ldarg_S, (byte)(pi++)); } Method_AtEvent_il.Emit(OpCodes.Call, k_Invoke); #endregion Method_AtEvent_il.Emit(OpCodes.Ret); #region this.Context[Event] = this[Event]; ctor_il.Emit(OpCodes.Ldarg_0); ctor_il.Emit(OpCodes.Ldfld, Field_Context); ctor_il.Emit(OpCodes.Ldarg_0); ctor_il.Emit(OpCodes.Ldftn, Method_AtEvent); ctor_il.Emit(OpCodes.Newobj, k.FieldType.GetConstructor(new[] { typeof(object), typeof(IntPtr) })); ctor_il.Emit(OpCodes.Stfld, k); #endregion } } #region InitializeReader var InitializeReader = t.DefineMethod("InitializeReader", MethodAttributes.Public, CallingConventions.HasThis, typeof(void), new[] { typeof(Stream) }); var InitializeReader_il = InitializeReader.GetILGenerator(); var InitializeReader_Reader = InitializeReader_il.DeclareLocal(typeof(BinaryReader)); var InitializeReader_ins = InitializeReader_il.DeclareLocal(typeof(int)); InitializeReader_il.Emit(OpCodes.Ldarg_1); InitializeReader_il.Emit(OpCodes.Newobj, typeof(BinaryReader).GetConstructor(new[] { typeof(Stream) })); InitializeReader_il.Emit(OpCodes.Stloc, InitializeReader_Reader); InitializeReader_il.EmitWriteLine("InitializeReader"); var InitializeReader_Continue = InitializeReader_il.DefineLabel(); InitializeReader_il.MarkLabel(InitializeReader_Continue); InitializeReader_il.Emit(OpCodes.Ldloc, InitializeReader_Reader); InitializeReader_il.EmitCall(OpCodes.Callvirt, BinaryReader_ReadByte.Method, null); InitializeReader_il.Emit(OpCodes.Stloc, InitializeReader_ins); { var EventIndex = 0; foreach (var k in Events) { EventIndex++; var InitializeReader_il_skip = InitializeReader_il.DefineLabel(); InitializeReader_il.Emit(OpCodes.Ldloc, InitializeReader_ins); InitializeReader_il.Emit(OpCodes.Ldc_I4, EventIndex); InitializeReader_il.Emit(OpCodes.Ceq); InitializeReader_il.Emit(OpCodes.Brfalse, InitializeReader_il_skip); InitializeReader_il.Emit(OpCodes.Ldarg_0); InitializeReader_il.Emit(OpCodes.Ldfld, Fields_Event[EventIndex - 1]); #region sender index to identity InitializeReader_il.Emit(OpCodes.Ldnull); #endregion var k_Invoke = k.FieldType.GetMethod("Invoke"); foreach (var p in k_Invoke.GetParameters().Skip(1)) { if (p.ParameterType == typeof(int)) { InitializeReader_il.Emit(OpCodes.Ldloc, InitializeReader_Reader); InitializeReader_il.EmitCall(BinaryReader_ReadInt32); } else if (p.ParameterType == typeof(char)) { InitializeReader_il.Emit(OpCodes.Ldloc, InitializeReader_Reader); InitializeReader_il.EmitCall(BinaryReader_ReadChar); } else if (p.ParameterType == typeof(byte)) { InitializeReader_il.Emit(OpCodes.Ldloc, InitializeReader_Reader); InitializeReader_il.EmitCall(BinaryReader_ReadByte); } else if (p.ParameterType.IsClass) { var ClassDeserializer = EmitClassDeserializer(p.ParameterType); InitializeReader_il.Emit(OpCodes.Ldarg_0); InitializeReader_il.Emit(OpCodes.Ldloc, InitializeReader_Reader); InitializeReader_il.EmitCall(OpCodes.Call, ClassDeserializer, null); } } InitializeReader_il.Emit(OpCodes.Call, k_Invoke); InitializeReader_il.MarkLabel(InitializeReader_il_skip); } } InitializeReader_il.Emit(OpCodes.Br, InitializeReader_Continue); //InitializeReader_il.Emit(OpCodes.Ret); #endregion #region InitializeWriter var InitializeWriter = t.DefineMethod("InitializeWriter", MethodAttributes.Public, CallingConventions.HasThis, typeof(void), new[] { typeof(Stream) }); var InitializeWriter_il = InitializeWriter.GetILGenerator(); InitializeWriter_il.EmitWriteLine("InitializeWriter"); #region this.CurrentWriter = arguments[0]; InitializeWriter_il.Emit(OpCodes.Ldarg_0); InitializeWriter_il.Emit(OpCodes.Ldarg_1); InitializeWriter_il.Emit(OpCodes.Newobj, typeof(BinaryWriter).GetConstructor(new[] { typeof(Stream) })); InitializeWriter_il.Emit(OpCodes.Stfld, Field_CurrentWriter); #endregion InitializeWriter_il.Emit(OpCodes.Ret); #endregion ctor_il.EmitWriteLine("connecting..."); #region ConnectToRouter(InitializeWriter, InitializeReader) ctor_il.Emit(OpCodes.Ldarg_0); ctor_il.Emit(OpCodes.Ldftn, InitializeWriter); ctor_il.Emit(OpCodes.Newobj, typeof(Action <Stream>).GetConstructor(new[] { typeof(object), typeof(IntPtr) })); ctor_il.Emit(OpCodes.Ldarg_0); ctor_il.Emit(OpCodes.Ldftn, InitializeReader); ctor_il.Emit(OpCodes.Newobj, typeof(Action <Stream>).GetConstructor(new[] { typeof(object), typeof(IntPtr) })); Action <Action <Stream>, Action <Stream> > ConnectToRouter = PrimitiveServerBuilder.ConnectToRouter; ctor_il.EmitCall(ConnectToRouter); #endregion ctor_il.Emit(OpCodes.Ret); var tm = t.DefineMethod("MainSTA", MethodAttributes.Static, typeof(void), new[] { typeof(string[]) } ); var tmil = tm.GetILGenerator(); //tmil.EmitWriteLine(""); //tmil.EmitWriteLine("usage: layer1.exe /java this will convert to java server"); //tmil.EmitWriteLine("usage: layer1.exe /as this will convert to actionscript3 client"); //tmil.EmitWriteLine(""); //ScriptCoreLib.CompilerServices.PrimitiveServerBuilder.EmitVersionInformation(tmil); // Field_Context must be Canvas at this point if (typeof(Form).IsAssignableFrom(TargetType)) { Action Application_EnableVisualStyles = System.Windows.Forms.Application.EnableVisualStyles; Action <Form> Application_Run = System.Windows.Forms.Application.Run; tmil.Emit(OpCodes.Call, Application_EnableVisualStyles.Method); tmil.Emit(OpCodes.Newobj, ctor); tmil.Emit(OpCodes.Ldfld, Field_Context); tmil.Emit(OpCodes.Call, Application_Run.Method); } if (typeof(Canvas).IsAssignableFrom(TargetType)) { Func <Canvas, Window> _ToWindow = ScriptCoreLib.CSharp.Avalon.Extensions.AvalonExtensions.ToWindow; MethodInfo _ShowDialog = typeof(Window).GetMethod("ShowDialog"); tmil.Emit(OpCodes.Newobj, ctor); tmil.Emit(OpCodes.Ldfld, Field_Context); tmil.EmitCall(OpCodes.Call, _ToWindow.Method, null); tmil.EmitCall(OpCodes.Call, _ShowDialog, null); tmil.Emit(OpCodes.Pop); } //tmil.EmitCall(OpCodes.Call, TargetType.GetMethod("GatherUserInput"), null); tmil.Emit(OpCodes.Ret); var main = t.DefineMethod("Main", MethodAttributes.Static, typeof(void), new[] { typeof(string[]) } ); var main_il = main.GetILGenerator(); main_il.Emit(OpCodes.Ldnull); main_il.Emit(OpCodes.Ldftn, tm); main_il.Emit(OpCodes.Newobj, typeof(ParameterizedThreadStart).GetConstructors().Single()); main_il.Emit(OpCodes.Newobj, typeof(Thread).GetConstructor(new[] { typeof(ThreadStart) })); Action <ApartmentState> Thread_SetApartmentState = new Thread(delegate() { }).SetApartmentState; Action <object> Thread_Start = new Thread(delegate() { }).Start; Action Thread_Join = new Thread(delegate() { }).Join; main_il.Emit(OpCodes.Dup); main_il.Emit(OpCodes.Ldc_I4, (int)ApartmentState.STA); main_il.EmitCall(Thread_SetApartmentState); main_il.Emit(OpCodes.Dup); main_il.Emit(OpCodes.Ldarg_0); main_il.EmitCall(Thread_Start); //main_il.Emit(OpCodes.Ldarg_0); //main_il.EmitCall(OpCodes.Call, server_EntryPoint, null); main_il.EmitCall(Thread_Join); main_il.Emit(OpCodes.Ret); t.CreateType(); PeerAssembly.SetEntryPoint(main); //a.AddResource("name1.name2.ken.txt", "hello world"); //a.AddResource("Layer1Assembly.assets.Layer1Assembly.about.txt", "kenny"); //a.DefineResource("log1", "desc1", "f1").AddResource("key1", "value1"); Environment.CurrentDirectory = Arguments.Assembly.Directory.FullName; var PeerFile = new FileInfo(PeerAssemblyName.Name + ".exe"); Console.WriteLine("peer: " + PeerFile.FullName); PeerAssembly.Save(PeerFile.Name); }
/// <summary> /// Adds <see cref="JsonSerializer"/> serializer while configuring it /// </summary> /// <param name="builder">builder</param> /// <param name="setupAction">The configuration action</param> public static void AddJson(this SerializationBuilder builder, Action <JsonOptions> setupAction) { builder.Configure(setupAction); builder.AddJson(); }
/// <summary> /// Adds <see cref="JsonSerializer"/> serializer /// </summary> /// <param name="builder">builder</param> public static void AddJson(this SerializationBuilder builder) { builder.AddSerializer <JsonSerializer, JsonOptions>(ServiceLifetime.Singleton); }
/// <summary> /// Adds <see cref="XmlSerializer"/> serializer while configuring it /// </summary> /// <param name="builder">builder</param> /// <param name="setupAction">The configuration action</param> public static void AddXml(this SerializationBuilder builder, Action <XmlOptions> setupAction) { builder.Configure(setupAction); builder.AddXml(); }
/// <summary> /// Adds <see cref="XmlSerializer"/> serializer /// </summary> /// <param name="builder">builder</param> public static void AddXml(this SerializationBuilder builder) { builder.AddSerializer <XmlSerializer, XmlOptions>(ServiceLifetime.Singleton); }
/// <summary> /// Adds <see cref="MessagePackSerializer"/> serializer while configuring it /// </summary> /// <param name="builder">builder</param> /// <param name="setupAction">The configuration action</param> public static void AddMessagePack(this SerializationBuilder builder, Action <MessagePackOptions> setupAction) { builder.Configure(setupAction); builder.AddMessagePack(); }
/// <summary> /// Adds <see cref="MessagePackSerializer"/> serializer /// </summary> /// <param name="builder">builder</param> public static void AddMessagePack(this SerializationBuilder builder) { builder.AddSerializer <MessagePackSerializer, MessagePackOptions>(ServiceLifetime.Singleton); }
/// <summary> /// Adds <see cref="ProtoBufSerializer"/> serializer while configuring it /// </summary> /// <param name="builder">builder</param> /// <param name="setupAction">The configuration action</param> public static void AddProtoBuf(this SerializationBuilder builder, Action <ProtoBufOptions> setupAction) { builder.Configure(setupAction); builder.AddProtoBuf(); }
/// <summary> /// Adds <see cref="ProtoBufSerializer"/> serializer /// </summary> /// <param name="builder">builder</param> public static void AddProtoBuf(this SerializationBuilder builder) { builder.AddSerializer <ProtoBufSerializer, ProtoBufOptions>(ServiceLifetime.Singleton); }