/// <summary>
/// Converts source values to a value for the binding target. The data binding
// engine calls this method when it propagates the values from source bindings
// to the binding target.
/// </summary>
public object Convert(object[] values, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
var options = new DeserializationOptions();
if (!(bool)values[0])
{
options.DeserializeColumns = false;
}
if (!(bool)values[1])
{
options.DeserializeGrouping = false;
}
if (!(bool)values[2])
{
options.DeserializeSorting = false;
}
if (!(bool)values[3])
{
options.DeserializeFiltering = false;
}
if (!(bool)values[4])
{
options.DeserializeGroupSummaries = false;
}
if (!(bool)values[5])
{
options.DeserializeTableSummaries = false;
}
if (!(bool)values[6])
{
options.DeserializeStackedHeaders = false;
}
return(options);
}
internal DeserializationContext(
DeserializationOptions options,
PSRemotingCryptoHelper cryptoHelper)
{
this.options = options;
this.cryptoHelper = cryptoHelper;
}
private void OnDeserialize(object obj)
{
var dataGrid = obj as SfDataGrid;
using (var file = File.Open("DataGrid.xml", FileMode.Open))
{
DeserializationOptions options = new DeserializationOptions();
options.DeserializeFiltering = true;
dataGrid.Deserialize(file, options);
}
}
private async void OnDeserialize(object obj)
{
var dataGrid = obj as SfDataGrid;
var folder = ApplicationData.Current.LocalFolder;
var storageFile = await folder.GetFileAsync("DataGrid.xml");
DeserializationOptions options = new DeserializationOptions();
options.DeserializeFiltering = true;
dataGrid.Deserialize(storageFile, options);
}
public void Overrides()
{
DeserializationOptions options = new DeserializationOptions();
options.Overrides.Add(typeof(Z), "aaa", (t, reader) => ((Z)t).aaa = reader.Expect <Scalar>().Value.ToUpperInvariant());
YamlSerializer serializer = new YamlSerializer();
object result = serializer.Deserialize(YamlFile("explicitType.yaml"), options);
Assert.True(typeof(Z).IsAssignableFrom(result.GetType()));
Assert.Equal("BBB", ((Z)result).aaa);
}
public void Overrides()
{
DeserializationOptions options = new DeserializationOptions();
options.Overrides.Add(typeof(Z), "aaa", (t, reader) => ((Z)t).aaa = reader.Expect <Scalar>().Value.ToUpperInvariant());
YamlSerializer serializer = new YamlSerializer();
object result = serializer.Deserialize(YamlFile("explicitType.yaml"), options);
Assert.IsTrue(typeof(Z).IsAssignableFrom(result.GetType()), "The deserializer should have used the correct type.");
Assert.AreEqual("BBB", ((Z)result).aaa, "The property has the wrong value.");
}
public void HasSettings_DefaultObject_ReturnsFalse()
{
// Arrange
var settings = new DeserializationOptions();
// Act
var result = settings.HasSettings;
// Assert
Assert.False(result);
}
public void CustomTags()
{
DeserializationOptions options = new DeserializationOptions();
options.Mappings.Add("tag:yaml.org,2002:point", typeof(Point));
YamlSerializer serializer = new YamlSerializer();
object result = serializer.Deserialize(YamlFile("tags.yaml"), options);
Assert.Equal(typeof(Point), result.GetType());
Point value = (Point)result;
Assert.Equal(10, value.X);
Assert.Equal(20, value.Y);
}
public void CustomTags()
{
DeserializationOptions options = new DeserializationOptions();
options.Mappings.Add("tag:yaml.org,2002:point", typeof(Point));
YamlSerializer serializer = new YamlSerializer();
object result = serializer.Deserialize(YamlFile("tags.yaml"), options);
Assert.AreEqual(typeof(Point), result.GetType(), "The deserializer should have used the correct type.");
Point value = (Point)result;
Assert.AreEqual(10, value.X, "The property X has the wrong value.");
Assert.AreEqual(20, value.Y, "The property Y has the wrong value.");
}
public void HasSettings_WithCustomObjectCreator_ReturnsTrue()
{
// Arrange
var settings = new DeserializationOptions()
{
CustomObjectCreator = new Mock <ICustomObjectCreator>().Object
};
// Act
var result = settings.HasSettings;
// Assert
Assert.True(result);
}
private async void OnDeserializeDataGrid(object sender, RoutedEventArgs e) {
var folder = ApplicationData.Current.LocalFolder;
try {
var storageFile = await folder.GetFileAsync("DataGrid.xml");
var options = new DeserializationOptions() {
DeserializeColumns = (bool)this.DeserializeColumns.IsChecked,
DeserializeFiltering = (bool)this.DeserializeFiltering.IsChecked,
DeserializeSorting = (bool)this.DeserializeSorting.IsChecked,
DeserializeGrouping = (bool)this.DeserializeGrouping.IsChecked,
DeserializeGroupSummaries = (bool)this.DeserializeGroupSummaries.IsChecked,
DeserializeTableSummaries = (bool)this.DeserializeTableSummaries.IsChecked,
DeserializeStackedHeaders = (bool)this.DeserializeStackedHeaders.IsChecked
};
this.sfDataGrid.Deserialize(storageFile, options);
}
catch (Exception) {
}
}
public void DeserializationOptions_Modification_UpdatesEffectiveSettings()
{
// Arrange
var options = new DeserializationOptions();
var effectiveSettings = new JsonSerializerSettings();
var serializer = new Mock <DefaultSerializer>
{
CallBase = true
};
serializer.Setup(p => p.GetDeserializationSettings(It.IsAny <JsonSerializerSettings>(), options))
.Returns(effectiveSettings);
// Act
serializer.Object.DeserializationOptions = options;
// Assert
Assert.AreEqual(effectiveSettings, serializer.Object.EffectiveDeserializationSettings);
}
/// <summary>
/// This load the parameters
/// </summary>
/// <param name="dataGrid">DataGrid to be used</param>
/// <param name="serializedString">The serialized string to be used</param>
private static void LoadParameters(SfDataGrid dataGrid, string serializedString)
{
DeserializationOptions options = new DeserializationOptions();
options.DeserializeFiltering = false;
if (string.IsNullOrEmpty(serializedString))
{
return;
}
using (MemoryStream ms = new MemoryStream())
{
using (StreamWriter writer = new StreamWriter(ms))
{
writer.Write(serializedString);
writer.Flush();
byte[] byteArray = ms.ToArray();
using (MemoryStream reader = new MemoryStream(byteArray))
{
dataGrid.Deserialize(reader, options);
}
}
}
}
public static void CustomDeserialize(this SfDataGrid dataGrid, byte[] disposition, bool deserializeDetailsViewDefinition = false)
{
DeserializationOptions options = new DeserializationOptions
{
DeserializeColumns = true,
DeserializeSorting = true
};
if (deserializeDetailsViewDefinition)
{
options.DeserializeDetailsViewDefinition = true;
}
using (MemoryStream ms = new MemoryStream(disposition))
{
dataGrid.Deserialize(ms, options);
dataGrid.AllowDraggingColumns = false;
dataGrid.AllowResizingColumns = false;
dataGrid.AllowResizingHiddenColumns = false;
dataGrid.AllowSorting = false;
dataGrid.AllowEditing = false;
dataGrid.HideEmptyGridViewDefinition = true;
}
}
private async void OnDeserializeDataGrid(object sender, Microsoft.UI.Xaml.RoutedEventArgs e)
{
var folder = ApplicationData.Current.LocalFolder;
try
{
var storageFile = await folder.GetFileAsync("DataGrid.xml");
var options = new DeserializationOptions()
{
DeserializeColumns = (bool)this.DeserializeColumns.IsChecked,
DeserializeFiltering = (bool)this.DeserializeFiltering.IsChecked,
DeserializeSorting = (bool)this.DeserializeSorting.IsChecked,
DeserializeGrouping = (bool)this.DeserializeGrouping.IsChecked,
DeserializeGroupSummaries = (bool)this.DeserializeGroupSummaries.IsChecked,
DeserializeTableSummaries = (bool)this.DeserializeTableSummaries.IsChecked,
DeserializeStackedHeaders = (bool)this.DeserializeStackedHeaders.IsChecked
};
this.sfDataGrid.Deserialize(storageFile, options);
}
catch (Exception)
{
}
}
protected internal virtual JsonSerializerSettings GetDeserializationSettings(JsonSerializerSettings baseSettings, DeserializationOptions options)
{
if ((options == null) || !options.HasSettings)
{
// No custom deserialization, so use baseSettings directly
return(baseSettings);
}
var settings = new JsonSerializerSettings()
{
Binder = baseSettings.Binder,
CheckAdditionalContent = baseSettings.CheckAdditionalContent,
ConstructorHandling = baseSettings.ConstructorHandling,
Context = baseSettings.Context,
ContractResolver = baseSettings.ContractResolver,
Converters = new List <JsonConverter>(baseSettings.Converters),
Culture = baseSettings.Culture,
DateFormatHandling = baseSettings.DateFormatHandling,
DateFormatString = baseSettings.DateFormatString,
DateParseHandling = baseSettings.DateParseHandling,
DateTimeZoneHandling = baseSettings.DateTimeZoneHandling,
DefaultValueHandling = baseSettings.DefaultValueHandling,
FloatFormatHandling = baseSettings.FloatFormatHandling,
FloatParseHandling = baseSettings.FloatParseHandling,
Formatting = baseSettings.Formatting,
MaxDepth = baseSettings.MaxDepth,
NullValueHandling = baseSettings.NullValueHandling,
ObjectCreationHandling = baseSettings.ObjectCreationHandling,
PreserveReferencesHandling = baseSettings.PreserveReferencesHandling,
ReferenceLoopHandling = baseSettings.ReferenceLoopHandling,
StringEscapeHandling = baseSettings.StringEscapeHandling,
TraceWriter = baseSettings.TraceWriter,
TypeNameAssemblyFormat = baseSettings.TypeNameAssemblyFormat,
TypeNameHandling = baseSettings.TypeNameHandling
};
if (baseSettings.ReferenceResolver != null)
{
// Backwards compatibility issue in Newtonsoft.Json 7.0.1 causes setting a null reference resolver to error instead of using default
settings.ReferenceResolver = baseSettings.ReferenceResolver;
}
if (options.CustomObjectCreator != null)
{
settings.Converters.Add(new JsonNetCustomObjectCreatorWrapper(options.CustomObjectCreator));
}
return(settings);
}
internal DeserializationContext(DeserializationOptions options, PSRemotingCryptoHelper cryptoHelper)
{
this.cimClassSerializationIdCache = new CimClassDeserializationCache<CimClassSerializationId>();
this.options = options;
this.cryptoHelper = cryptoHelper;
}
internal DeserializationContext(DeserializationOptions options, PSRemotingCryptoHelper cryptoHelper)
{
this.cimClassSerializationIdCache = new CimClassDeserializationCache <CimClassSerializationId>();
this.options = options;
this.cryptoHelper = cryptoHelper;
}
