/// <summary> /// Binary saves the diagram /// </summary> /// <param name="fileName">the file-path</param> /// <param name="control">The control.</param> /// <returns></returns> public static bool SaveAs(string fileName, DiagramControlBase control) { FileStream fs = new FileStream(fileName, FileMode.Create); GenericFormatter<BinaryFormatter> f = new GenericFormatter<BinaryFormatter>(); try { Document document = control.Document; //Warning!: cleaning up, you need to unhook all events since // unserializable classes hooked to events will give problems. f.Serialize<Document>(fs, document); return true; } catch (Exception exc) { //site.OutputInfo("The graph was not saved, because some graph events were attached to non-serializable classes.\r\n This is a known issue and will be resolved in a later stadium.",OutputInfoLevels.Exception); Trace.WriteLine(exc.Message, "BinarySerializer.SaveAs"); //DumpInfo(); } finally { fs.Close(); } return false; }
static PrettyPrintMinimod() { var settings = new Settings(); // integration with PrettyTypeSignatures settings.RegisterFormatterFor <Type>(PrettyTypeSignaturesMinimod.GetPrettyName); settings.RegisterFormatterFor <MethodBase>(PrettyTypeSignaturesMinimod.GetPrettyName); settings.RegisterFormatterFor <StackFrame>(PrettyTypeSignaturesMinimod.GetPrettyName); // integration with PrettyDateAndTime settings.RegisterFormatterFor <DateTime>(PrettyDateAndTimeMinimod.GetPrettyString); settings.RegisterFormatterFor <DateTimeOffset>(PrettyDateAndTimeMinimod.GetPrettyString); settings.RegisterFormatterFor <TimeSpan>(PrettyDateAndTimeMinimod.GetPrettyString); settings.RegisterFormatterFor <Guid>(formatter); // decimal is not a simple type? settings.RegisterFormatterFor <decimal>(d => d + "m"); GenericFormatter.Register(settings); FileSystemInfoFormatter.Register(settings); settings.OmitNullMembers(true); DefaultSettings = settings; }
/// <summary> /// Called when the tool is activated. /// </summary> protected override void OnActivateTool() { try { // Used to get a collection of entities from the // NetronClipboard. Type entitiesType = typeof(CollectionBase<IDiagramEntity>); // First calculate the insertion point based on the // current location of the cursor. InsertionPoint = Point.Round( Controller.View.ViewToWorld( Controller.View.DeviceToView( Controller.ParentControl.PointToClient(Cursor.Position)))); IDataObject data = Clipboard.GetDataObject(); string format = typeof(CopyTool).FullName; if (data.GetDataPresent(format)) { MemoryStream stream = data.GetData(format) as MemoryStream; CollectionBase<IDiagramEntity> collection = null; GenericFormatter<BinaryFormatter> f = new GenericFormatter<BinaryFormatter>(); //Anchors collection is a helper collection to re-connect connectors to their parent Anchors.Clear(); //but is it actually a stream coming this application? collection = f.Deserialize<CollectionBase<IDiagramEntity>>(stream); UnwrapBundle(collection); } else if (NetronClipboard.ContainsData(entitiesType)) { CollectionBase<IDiagramEntity> collection = (CollectionBase<IDiagramEntity>)NetronClipboard.Get( entitiesType); UnwrapBundle(collection.DeepCopy()); } else if (data.GetDataPresent(DataFormats.Bitmap)) { Bitmap bmp = data.GetData(DataFormats.Bitmap) as Bitmap; if (bmp != null) { #region Unwrap into an image shape //TODO: Insert the image shape here ImageShape shape = new ImageShape(); shape.Image = bmp; shape.Location = InsertionPoint; Controller.Model.AddShape(shape); #endregion } } else if (data.GetDataPresent(DataFormats.Text)) { string text = (string)data.GetData(typeof(string)); TextOnly textShape = new TextOnly(Controller.Model); textShape.Text = text; textShape.Location = InsertionPoint; Controller.Model.AddShape(textShape); } } catch (Exception exc) { throw new InconsistencyException("The Paste operation failed.", exc); } finally { DeactivateTool(); } }
public void Format() { IFormatter formatter = new GenericFormatter(); Assert.AreEqual("1", formatter.Format(1, "")); Assert.AreEqual("(null)", formatter.Format(null, "")); Assert.AreEqual("Formatter", formatter.Format("Formatter", "")); }
protected void gvClientPagePermissions_RowDataBound(object sender, GridViewRowEventArgs e) { if (e.Row.RowType == DataControlRowType.DataRow) { var d = (ClientPagePermissions)e.Row.DataItem; ((CheckBox)e.Row.FindControl("chk")).Checked = false; ((Label)e.Row.FindControl("LblPageName")).Text = GenericFormatter.GetEnumDescription(d); ((HiddenField)e.Row.FindControl("hfpid")).Value = ((int)d).ToString(); } }
private static string PrettyPrint(this object anyObject, Type declaredType, Settings settings, Stack parents) { parents = parents ?? new Stack(); if (anyObject == null) { return("<null" + (declaredType != typeof(object) ? ", " + declaredType.GetPrettyName() : "") + ">"); } if (parents.Contains(anyObject)) { return("<loop" + (declaredType != typeof(object) ? ", " + declaredType.GetPrettyName() : "") + ">"); } parents.Push(anyObject); try { var formatter = settings.GetCustomFormatter(anyObject); if (formatter != null) { return(formatter(anyObject)); } var actualType = anyObject.GetType(); if (anyObject is string) { var s = (string)anyObject; return(s == String.Empty ? "<String.Empty>" : s); } if (actualType.IsPrimitive) { return(anyObject.ToString()); } if (anyObject is IEnumerable) { return(enumerable(anyObject as IEnumerable, declaredType, settings)); } if (declaredType.IsEnum && Enum.IsDefined(declaredType, anyObject)) { return(String.Format("<{0}.{1} = {2}>", declaredType.Name, Enum.GetName(declaredType, anyObject), (int)anyObject)); } return(GenericFormatter.Format(actualType, anyObject, settings, parents)); } finally { parents.Pop(); } }
internal void FillEnum(DropDownList cmb, Type type, bool addSelectValue = true) { AddSelectItemForCombo(cmb); foreach (Enum item in Enum.GetValues(type)) { string description = GenericFormatter.GetEnumDescription(item); cmb.Items.Add(new System.Web.UI.WebControls.ListItem { Text = description, Value = Convert.ToInt32(item).ToString() }); } }
protected override void OnInit(EventArgs e) { base.OnInit(e); Page.PreRender += new EventHandler(PagePreRender); if (!LoginProvider && CurrentUser == null) { SynNavigation.Goto(Pages.Login); } if (!IsPostBack) { if (RequiredPermissions.NotEmpty()) { Title = GenericFormatter.GetEnumDescription(RequiredPermissions[0]); } else { Title = "מסך הבית"; } if (!LoginProvider) { BuildSiteMapLinks(); bool navSelected = false; if (RequiredPermissions.NotEmpty()) { var requiredPermis = RequiredPermissions.FirstOrDefault(); PageLinkAttribute HasNavLink = GetPageLink(requiredPermis); if (HasNavLink != null) { ((HtmlAnchor)Master.FindControl(HasNavLink.NavLink)).Attributes.Add("class", "active"); navSelected = true; } } if (!navSelected) { ((HtmlAnchor)Master.FindControl(DefaultNavItem)).Attributes.Add("class", "active"); } (Master as WebSimplify.WebSimplify).CurrentUserName = CurrentUser.DisplayName ?? CurrentUser.UserName; (Master as WebSimplify.WebSimplify).IsAdmin = CurrentUser.IsAdmin; } foreach (ClientPagePermissions en in RequiredPermissions) { if (!CurrentUser.Allowed(en)) { SynNavigation.Goto(Pages.Main); } } } }
/// <summary> /// Opens the binary-saved diagram /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="control">The control.</param> public static bool Open(string fileName, DiagramControlBase control) { FileStream fs = null; try { fs = File.OpenRead(fileName); } catch (System.IO.DirectoryNotFoundException exc) { System.Windows.Forms.MessageBox.Show(exc.Message); } catch (System.IO.FileLoadException exc) { System.Windows.Forms.MessageBox.Show(exc.Message); } catch (System.IO.FileNotFoundException exc) { System.Windows.Forms.MessageBox.Show(exc.Message); } catch (Exception exc) { throw new Exception("Non-CLS exception caught.", exc); } //donnot open anything if filestream is not there if (fs == null) { return false; } try { GenericFormatter<BinaryFormatter> f = new GenericFormatter<BinaryFormatter>(); //one-line deserialization, no bits 'nd bytes necessary....C# is amazing... Document document = f.Deserialize<Document>(fs); if (document == null) throw new InconsistencyException("The deserialization return 'null'."); //call the standard method at the control level to attach a new document //In principle you could create a document programmatically and attach it this way as well. control.AttachToDocument(document); return true; } catch (SerializationException exc) { MessageBox.Show(exc.Message); } catch (System.Reflection.TargetInvocationException exc) { MessageBox.Show(exc.Message, "BinarySerializer.Open"); } catch (Exception exc) { MessageBox.Show(exc.Message, "BinarySerializer.Open"); } finally { if (fs != null) { fs.Close(); } } return false; }
public override string ToString() { StringBuilder sb = new StringBuilder(); sb.AppendFormat("[{0}] ", FieldName); sb.AppendFormat("[{0}] ", GenericFormatter.GetEnumDescription(FieldType)); if (FieldLLenght != 0) { sb.AppendFormat(" ({0}) ", FieldLLenght); } sb.Append(IsNullAble ? "NULL" : "NOT NULL"); return(sb.ToString()); }
protected void gvAdd_RowDataBound(object sender, GridViewRowEventArgs e) { if (e.Row.RowType == DataControlRowType.DataRow) { var cmbShifts = ((DropDownList)e.Row.FindControl("cmbShifts")); ((TextBox)e.Row.FindControl("txDate")).Text = string.Empty; foreach (Enum se in Enum.GetValues(typeof(ShiftTime))) { ListItem item = new ListItem(GenericFormatter.GetEnumDescription(se), (se).ToString()); cmbShifts.Items.Add(item); } } }
/// <summary> /// Called when the tool is activated. /// </summary> protected override void OnActivateTool() { try { IDataObject data = Clipboard.GetDataObject(); string format = typeof(CopyTool).FullName; if (data.GetDataPresent(format)) { MemoryStream stream = data.GetData(format) as MemoryStream; CollectionBase<IDiagramEntity> collection = null; GenericFormatter<BinaryFormatter> f = new GenericFormatter<BinaryFormatter>(); //Anchors collection is a helper collection to re-connect connectors to their parent Anchors.Clear(); //but is it actually a stream coming this application? collection = f.Deserialize<CollectionBase<IDiagramEntity>>(stream); if (collection != null) { #region Unwrap the bundle this.Controller.Model.Unwrap(collection); Rectangle rec = Utils.BoundingRectangle(collection); rec.Inflate(30, 30); this.Controller.View.Invalidate(rec); #endregion } } else if (data.GetDataPresent(DataFormats.Bitmap)) { Bitmap bmp = data.GetData(DataFormats.Bitmap) as Bitmap; if (bmp != null) { #region Unwrap into an image shape //TODO: Insert the image shape here #endregion } } } catch (Exception exc) { throw new InconsistencyException("The Copy operation failed.", exc); } finally { DeactivateTool(); } }
public static IFormatter <T> Create <T>() { Debug.Assert(typeof(T).IsArray); var elementType = typeof(T).GetElementType(); if (!GenericFormatter.IsSerializableType(elementType)) { return(null); } if (typeof(T).GetArrayRank() == 1 && typeof(T) == elementType.MakeArrayType()) { return(CreateSZArrayFormatter <T>(elementType)); } return(CreateMultidimensionalArrayFormatter <T>(elementType)); }
public ActionResult Format([FromBody] FormatRequest request) { if (request == null) { return(Content("Invalid Input parameters.")); } if (string.IsNullOrWhiteSpace(request.InputText)) { return(Content("Input your text.")); } var splittedSentences = _formatter.Format(request.InputText); var genericFormatter = new GenericFormatter(); var formatter = genericFormatter.Create((FormatType)request.FormatType); return(Content(formatter.Format(splittedSentences))); }
private static bool IsSerializableSubType <T>(Type type) { if (type == null) { return(false); } if (type == typeof(T)) { return(false); } if (!typeof(T).IsAssignableFrom(type)) { return(false); } return(GenericFormatter.IsSerializableType(type)); }
protected override IList <Request> GetRequestsForTask(Guid taskId) { var requests = new List <Request>(); var items = queueRepository.ListByTask(taskId, TotalItems); var formatter = new GenericFormatter(); foreach (var item in items) { var content = formatter.GetJsonContent(item.Id, Properties); if (!String.IsNullOrEmpty(content)) { var request = new Request(item.Id, (int)item.Key, content, true); requests.Add(request); } } return(requests); }
public static string FormatSignature(string declStr, int genQty) { var func = new GenericFormatter(); var parameters = new List <GenericFormatter>(); var split = declStr.Split('('); var pars = split.Last().Split(')').First().Split(','); var split2 = split.First().Split('<'); func.preText = split2.First(); func.postText = ""; func.generics = split2.Last().Split('>').First().Split(',').ToList(); foreach (string par in pars) { if (par.Contains('<')) { var nam = par.Split('<').First(); var pgens = par.Split('<').Last().Split('>').First().Split(',').ToList(); var e = par.Split('<').Last().Split('>').Last(); parameters.Add(new GenericFormatter(nam, e, pgens)); } else { parameters.Add(new GenericFormatter(par, "", null)); //if parameter is a generic (todo get generic parameters) repeat for qty if (par.Split(' ').Any(x => x == "T0")) { for (int i = 1; i < genQty; i++) { parameters.Add(new GenericFormatter(Utils.IncrementGeneric(par, i), "", null)); } } } } return($"{func.Format(genQty)}({string.Join(", ",parameters.Select(x=>x.Format(genQty)))})"); }
private static (Dictionary <string, FieldInfo> initOnlyFields, FieldInfo[] fields) GetFields(Type type) { var initOnlyFields = new Dictionary <string, FieldInfo>(StringComparer.OrdinalIgnoreCase); var fields = new List <FieldInfo>(); var currentType = type; do { foreach (var field in currentType.GetFields(BindingFlagsEx.DeclaredInstance)) { if (field.IsNotSerialized) { continue; } if (!GenericFormatter.IsSerializableType(field.FieldType)) { continue; } if (field.IsInitOnly) { var fieldOrPropertyName = GetFieldOrPropertyName(field); if (!initOnlyFields.ContainsKey(fieldOrPropertyName)) { initOnlyFields.Add(fieldOrPropertyName, field); } } else { fields.Add(field); } } } while ((currentType = currentType.BaseType) != null); return(initOnlyFields, fields.ToArray()); }
private static void SerializeField <T>(ILGenerator il, FieldInfo field) { var type = PrimitiveTypes.GetPrimitiveType(field.FieldType); if (type == PrimitiveType.NotPrimitive) { GenericFormatter.EmitLoadCachedInstance(il, field.FieldType); } LoadFieldValue <T>(il, field); il.EmitLoadArgument(1); il.EmitLoadArgument(2); il.EmitLoadArgument(3); switch (type) { case PrimitiveType.NotPrimitive: il.EmitLoadArgument(4); il.EmitLoadArgument(5); GenericFormatter.EmitSerialize(il, field.FieldType); break; case PrimitiveType.SByte: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWriteSByte), BindingFlagsEx.Static)); break; case PrimitiveType.Byte: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWriteByte), BindingFlagsEx.Static)); break; case PrimitiveType.Int16: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWriteInt16), BindingFlagsEx.Static)); break; case PrimitiveType.UInt16: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWriteUInt16), BindingFlagsEx.Static)); break; case PrimitiveType.Int32: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWrite7BitEncodedInt32), BindingFlagsEx.Static)); break; case PrimitiveType.UInt32: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWrite7BitEncodedUInt32), BindingFlagsEx.Static)); break; case PrimitiveType.Int64: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWrite7BitEncodedInt64), BindingFlagsEx.Static)); break; case PrimitiveType.UInt64: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWrite7BitEncodedUInt64), BindingFlagsEx.Static)); break; case PrimitiveType.Boolean: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWriteBoolean), BindingFlagsEx.Static)); break; case PrimitiveType.Char: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWriteChar), BindingFlagsEx.Static)); break; case PrimitiveType.Single: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWriteSingle), BindingFlagsEx.Static)); break; case PrimitiveType.Double: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWriteDouble), BindingFlagsEx.Static)); break; default: Debug.Assert(false); break; } }
public TableCellParser(string input, GenericFormatter formatter) { _lineFragment = input; _formatter = formatter; }
public static string GetDescription(this Enum e) { return GenericFormatter.GetEnumDescription(e); }
private static void GetFieldSize <T>(ILGenerator il, FieldInfo field) { var type = PrimitiveTypes.GetPrimitiveType(field.FieldType); if (type == PrimitiveType.NotPrimitive) { GenericFormatter.EmitLoadCachedInstance(il, field.FieldType); } LoadFieldValue <T>(il, field); switch (type) { case PrimitiveType.NotPrimitive: il.EmitLoadArgument(1); il.EmitLoadArgument(2); GenericFormatter.EmitGetSize(il, field.FieldType); break; case PrimitiveType.SByte: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGetSByteSize), BindingFlagsEx.Static)); break; case PrimitiveType.Byte: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGetByteSize), BindingFlagsEx.Static)); break; case PrimitiveType.Int16: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGetInt16Size), BindingFlagsEx.Static)); break; case PrimitiveType.UInt16: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGetUInt16Size), BindingFlagsEx.Static)); break; case PrimitiveType.Int32: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGet7BitEncodedInt32Size), BindingFlagsEx.Static)); break; case PrimitiveType.UInt32: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGet7BitEncodedUInt32Size), BindingFlagsEx.Static)); break; case PrimitiveType.Int64: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGet7BitEncodedInt64Size), BindingFlagsEx.Static)); break; case PrimitiveType.UInt64: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGet7BitEncodedUInt64Size), BindingFlagsEx.Static)); break; case PrimitiveType.Boolean: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGetBooleanSize), BindingFlagsEx.Static)); break; case PrimitiveType.Char: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGetCharSize), BindingFlagsEx.Static)); break; case PrimitiveType.Single: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGetSingleSize), BindingFlagsEx.Static)); break; case PrimitiveType.Double: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGetDoubleSize), BindingFlagsEx.Static)); break; default: Debug.Assert(false); break; } }
private static SerializationFunc <T> CreateUnionSerializationFunc <T>(Type[] types) { var serialzationFunc = new DynamicMethod(string.Empty, typeof(int), new[] { typeof(T), typeof(byte[]), typeof(int), typeof(int), typeof(int), typeof(int) }, true); var il = serialzationFunc.GetILGenerator(); var indexBytesWritten = il.DeclareLocal(typeof(int)); { var valueNotNull = il.DefineLabel(); il.EmitLoadArgument(0); il.Emit(OpCodes.Brtrue_S, valueNotNull); il.EmitLoadDeclaredConstant(0); il.EmitLoadArgument(1); il.EmitLoadArgument(2); il.EmitLoadArgument(3); il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWrite7BitEncodedUInt32), BindingFlagsEx.Static)); il.Emit(OpCodes.Ret); il.MarkLabel(valueNotNull); } for (var i = 0; i < types.Length; i++) { var type = types[i]; var skipLabel = il.DefineLabel(); il.EmitLoadArgument(0); il.Emit(OpCodes.Isinst, type); il.Emit(OpCodes.Brfalse_S, skipLabel); il.EmitLoadDeclaredConstant(i + 1); il.EmitLoadArgument(1); il.EmitLoadArgument(2); il.EmitLoadArgument(3); il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWrite7BitEncodedUInt32), BindingFlagsEx.Static)); il.EmitStoreLocal(indexBytesWritten.LocalIndex); GenericFormatter.EmitLoadCachedInstance(il, type); il.EmitLoadArgument(0); if (type.IsClass) { il.Emit(OpCodes.Castclass, type); } else { Debug.Assert(type.IsValueType); il.Emit(OpCodes.Unbox_Any, type); } il.EmitLoadArgument(1); il.EmitLoadArgument(2); il.EmitLoadLocal(indexBytesWritten.LocalIndex); il.Emit(OpCodes.Add); il.EmitLoadArgument(3); il.EmitLoadLocal(indexBytesWritten.LocalIndex); il.Emit(OpCodes.Sub); il.EmitLoadArgument(4); il.EmitLoadArgument(5); GenericFormatter.EmitSerialize(il, type); il.EmitLoadLocal(indexBytesWritten.LocalIndex); il.Emit(OpCodes.Add); il.Emit(OpCodes.Ret); il.MarkLabel(skipLabel); } il.Emit(OpCodes.Ldstr, "Failed to serialize the object, because no implementation was found."); il.Emit(OpCodes.Ldstr, "value"); il.Emit(OpCodes.Newobj, typeof(ArgumentException).GetConstructor(new[] { typeof(string), typeof(string) })); il.Emit(OpCodes.Throw); return((SerializationFunc <T>)serialzationFunc.CreateDelegate(typeof(SerializationFunc <T>))); }
private static void DeserializeField(ILGenerator il, FieldInfo field, LocalBuilder size) { var type = PrimitiveTypes.GetPrimitiveType(field.FieldType); if (type == PrimitiveType.NotPrimitive) { GenericFormatter.EmitLoadCachedInstance(il, field.FieldType); } il.EmitLoadArgument(0); il.EmitLoadArgument(1); il.EmitLoadArgument(2); il.EmitLoadLocalAddress(size.LocalIndex); switch (type) { case PrimitiveType.NotPrimitive: il.EmitLoadArgument(4); il.EmitLoadArgument(5); GenericFormatter.EmitDeserialize(il, field.FieldType); break; case PrimitiveType.SByte: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalReadSByte), BindingFlagsEx.Static)); break; case PrimitiveType.Byte: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalReadByte), BindingFlagsEx.Static)); break; case PrimitiveType.Int16: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalReadInt16), BindingFlagsEx.Static)); break; case PrimitiveType.UInt16: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalReadUInt16), BindingFlagsEx.Static)); break; case PrimitiveType.Int32: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalRead7BitEncodedInt32), BindingFlagsEx.Static)); break; case PrimitiveType.UInt32: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalRead7BitEncodedUInt32), BindingFlagsEx.Static)); break; case PrimitiveType.Int64: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalRead7BitEncodedInt64), BindingFlagsEx.Static)); break; case PrimitiveType.UInt64: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalRead7BitEncodedUInt64), BindingFlagsEx.Static)); break; case PrimitiveType.Boolean: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalReadBoolean), BindingFlagsEx.Static)); break; case PrimitiveType.Char: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalReadChar), BindingFlagsEx.Static)); break; case PrimitiveType.Single: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalReadSingle), BindingFlagsEx.Static)); break; case PrimitiveType.Double: il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalReadDouble), BindingFlagsEx.Static)); break; default: Debug.Assert(false); break; } }
private static DeserializationFunc <T> CreateUnionDeserializationFunc <T>(Type[] types) { var deserialzationFunc = new DynamicMethod(string.Empty, typeof(T), new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int), typeof(int), typeof(int).MakeByRefType() }, true); var il = deserialzationFunc.GetILGenerator(); var index = il.DeclareLocal(typeof(int)); var indexSize = il.DeclareLocal(typeof(int)); var objectSize = il.DeclareLocal(typeof(int)); var result = il.DeclareLocal(typeof(T)); il.EmitLoadArgument(0); il.EmitLoadArgument(1); il.EmitLoadArgument(2); il.EmitLoadLocalAddress(indexSize.LocalIndex); il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalRead7BitEncodedInt32), BindingFlagsEx.Static)); il.EmitStoreLocal(index.LocalIndex); { var validIndex = il.DefineLabel(); il.EmitLoadLocal(index.LocalIndex); il.EmitLoadDeclaredConstant(types.Length); il.Emit(OpCodes.Ble_S, validIndex); il.Emit(OpCodes.Ldstr, "Failed to deserialize the object, because its union index was out of bounds."); il.Emit(OpCodes.Newobj, typeof(SerializationException).GetConstructor(new[] { typeof(string) })); il.Emit(OpCodes.Throw); il.MarkLabel(validIndex); } { var valueNotNull = il.DefineLabel(); il.EmitLoadLocal(result.LocalIndex); il.Emit(OpCodes.Brtrue_S, valueNotNull); il.EmitLoadArgument(5); il.EmitLoadLocal(indexSize.LocalIndex); il.Emit(OpCodes.Stind_I4); il.Emit(OpCodes.Ldnull); il.Emit(OpCodes.Ret); il.MarkLabel(valueNotNull); } il.EmitLoadArgument(1); il.EmitLoadLocal(indexSize.LocalIndex); il.Emit(OpCodes.Add); il.EmitStoreArgument(1); il.EmitLoadArgument(2); il.EmitLoadLocal(indexSize.LocalIndex); il.Emit(OpCodes.Sub); il.EmitStoreArgument(2); il.EmitLoadLocal(index.LocalIndex); il.EmitLoadDeclaredConstant(1); il.Emit(OpCodes.Sub); il.EmitStoreLocal(index.LocalIndex); var jumpTable = new Label[types.Length]; var endOfSwitch = il.DefineLabel(); for (var i = 0; i < types.Length; i++) { jumpTable[i] = il.DefineLabel(); } il.EmitLoadLocal(index.LocalIndex); il.Emit(OpCodes.Switch, jumpTable); for (var i = 0; i < types.Length; i++) { var type = types[i]; il.MarkLabel(jumpTable[i]); GenericFormatter.EmitLoadCachedInstance(il, type); il.EmitLoadArgument(0); il.EmitLoadArgument(1); il.EmitLoadArgument(2); il.EmitLoadArgument(3); il.EmitLoadArgument(4); il.EmitLoadLocalAddress(objectSize.LocalIndex); GenericFormatter.EmitDeserialize(il, type); if (type.IsValueType) { il.Emit(OpCodes.Box, type); } il.EmitStoreLocal(result.LocalIndex); il.Emit(OpCodes.Br, endOfSwitch); } il.MarkLabel(endOfSwitch); il.EmitLoadArgument(5); il.EmitLoadLocal(indexSize.LocalIndex); il.EmitLoadLocal(objectSize.LocalIndex); il.Emit(OpCodes.Add); il.Emit(OpCodes.Stind_I4); il.EmitLoadLocal(result.LocalIndex); il.Emit(OpCodes.Ret); return((DeserializationFunc <T>)deserialzationFunc.CreateDelegate(typeof(DeserializationFunc <T>))); }