public void Fill_InvalidProperty_UsesDefaultValue()
{
var target = new List<ScatterPoint>();
var filler = new ListBuilder<ScatterPoint>();
filler.Add("B", 0d);
filler.Fill(target, this.src, args => new ScatterPoint(Convert.ToDouble(args[0]), 0));
}
public void Fill_NullProperty_DefaultValueIsExpected()
{
var target = new List<ScatterPoint>();
var filler = new ListBuilder<ScatterPoint>();
filler.Add(null, 42);
filler.Fill(target, this.src, args => new ScatterPoint(Convert.ToDouble(args[0]), 0));
Assert.AreEqual(1, target.Count);
Assert.AreEqual(42, target[0].X);
}
public void FillDataPoints()
{
var target = new List<DataPoint>();
var filler = new ListBuilder<DataPoint>();
filler.Add("A", 0d);
filler.Fill(target, this.src, args => new DataPoint(Convert.ToDouble(args[0]), 0));
Assert.AreEqual(1, target.Count);
Assert.AreEqual(3.14, target[0].X);
}
protected override void Deserialize(object target, XmlElementContext context)
{
_listBuilder?.Begin(null, false);
var targetElements = XmlElementSerializer.GetElements(context.XElement, false, _rootTarget, -1)?.ToArray();
if (targetElements == null)
{
return;
}
foreach (var targetElement in targetElements)
{
_listBuilder?.Add(_serializer.Deserialize(targetElement));
}
SetValue(target, _listBuilder?.End());
}
protected sealed override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
{
Debug.Assert(types != null);
QueryResult <ConstructorInfo> queryResult = Query <ConstructorInfo>(bindingAttr);
ListBuilder <ConstructorInfo> candidates = new ListBuilder <ConstructorInfo>();
foreach (ConstructorInfo candidate in queryResult)
{
if (candidate.QualifiesBasedOnParameterCount(bindingAttr, callConvention, types))
{
candidates.Add(candidate);
}
}
// For perf and desktop compat, fast-path these specific checks before calling on the binder to break ties.
if (candidates.Count == 0)
{
return(null);
}
if (types.Length == 0 && candidates.Count == 1)
{
ConstructorInfo firstCandidate = candidates[0];
ParameterInfo[] parameters = firstCandidate.GetParametersNoCopy();
if (parameters.Length == 0)
{
return(firstCandidate);
}
}
if ((bindingAttr & BindingFlags.ExactBinding) != 0)
{
return(System.DefaultBinder.ExactBinding(candidates.ToArray(), types, modifiers) as ConstructorInfo);
}
if (binder == null)
{
binder = DefaultBinder;
}
return(binder.SelectMethod(bindingAttr, candidates.ToArray(), types, modifiers) as ConstructorInfo);
}
protected override void Deserialize(object target, HeaderdFileContext context)
{
Argument.NotNull(context, nameof(context));
if (string.IsNullOrEmpty(_keyName))
{
return;
}
_listBuilder?.Begin(null, false);
try
{
foreach (var contextEnry in context.Context[_keyName])
{
_listBuilder?.Add(_converter?.ConvertBack(contextEnry.Content));
}
}
finally
{
SetValue(target, _listBuilder?.End());
}
}
protected sealed override PropertyInfo?GetPropertyImpl(string name, BindingFlags bindingAttr, Binder?binder, Type?returnType, Type[]?types, ParameterModifier[]?modifiers)
{
Debug.Assert(name != null);
// GetPropertyImpl() is a funnel for two groups of api. We can distinguish by comparing "types" to null.
if (types == null && returnType == null)
{
// Group #1: This group of api accept only a name and BindingFlags. The other parameters are hard-wired by the non-virtual api entrypoints.
Debug.Assert(binder == null);
Debug.Assert(modifiers == null);
return(Query <PropertyInfo>(name, bindingAttr).Disambiguate());
}
else
{
// Group #2: This group of api takes a set of parameter types, a return type (both cannot be null) and an optional binder.
QueryResult <PropertyInfo> queryResult = Query <PropertyInfo>(name, bindingAttr);
ListBuilder <PropertyInfo> candidates = default;
foreach (PropertyInfo candidate in queryResult)
{
if (types == null || (candidate.GetIndexParameters().Length == types.Length))
{
candidates.Add(candidate);
}
}
if (candidates.Count == 0)
{
return(null);
}
// For perf and .NET Framework compat, fast-path these specific checks before calling on the binder to break ties.
if (types == null || types.Length == 0)
{
// no arguments
if (candidates.Count == 1)
{
PropertyInfo firstCandidate = candidates[0];
if (!(returnType is null) && !returnType.IsEquivalentTo(firstCandidate.PropertyType))
{
return(null);
}
return(firstCandidate);
}
else
{
if (returnType is null)
{
// if we are here we have no args or property type to select over and we have more than one property with that name
throw new AmbiguousMatchException();
}
}
}
if ((bindingAttr & BindingFlags.ExactBinding) != 0)
{
return(System.DefaultBinder.ExactPropertyBinding(candidates.ToArray(), returnType, types, modifiers));
}
if (binder == null)
{
binder = Loader.GetDefaultBinder();
}
return(binder.SelectProperty(bindingAttr, candidates.ToArray(), returnType, types, modifiers));
}
}
/// <summary>
/// Updates the points from the <see cref="ItemsSeries.ItemsSource" />.
/// </summary>
private void UpdateItemsSourcePoints()
{
// Use the Mapping property to generate the points
if (this.Mapping != null)
{
this.ClearItemsSourcePoints();
foreach (var item in this.ItemsSource)
{
this.itemsSourcePoints.Add(this.Mapping(item));
}
return;
}
var sourceAsListOfDataPoints = this.ItemsSource as List <DataPoint>;
if (sourceAsListOfDataPoints != null)
{
this.itemsSourcePoints = sourceAsListOfDataPoints;
this.ownsItemsSourcePoints = false;
return;
}
this.ClearItemsSourcePoints();
var sourceAsEnumerableDataPoints = this.ItemsSource as IEnumerable <DataPoint>;
if (sourceAsEnumerableDataPoints != null)
{
this.itemsSourcePoints.AddRange(sourceAsEnumerableDataPoints);
return;
}
// Get DataPoints from the items in ItemsSource
// if they implement IDataPointProvider
// If DataFields are set, this is not used
if (this.DataFieldX == null || this.DataFieldY == null)
{
foreach (var item in this.ItemsSource)
{
if (item is DataPoint)
{
this.itemsSourcePoints.Add((DataPoint)item);
continue;
}
var idpp = item as IDataPointProvider;
if (idpp == null)
{
continue;
}
this.itemsSourcePoints.Add(idpp.GetDataPoint());
}
}
else
{
var filler = new ListBuilder <DataPoint>();
filler.Add(this.DataFieldX, double.NaN);
filler.Add(this.DataFieldY, double.NaN);
filler.Fill(this.itemsSourcePoints, this.ItemsSource, args => new DataPoint(Convert.ToDouble(args[0]), Convert.ToDouble(args[1])));
}
}
/// <summary>
/// Updates the points from the <see cref="ItemsSeries.ItemsSource" />.
/// </summary>
private void UpdateItemsSourcePoints()
{
// Use the Mapping property to generate the points
if (this.Mapping != null)
{
this.ClearItemsSourcePoints();
foreach (var item in this.ItemsSource)
{
this.itemsSourcePoints.Add(this.Mapping(item));
}
return;
}
var sourceAsListOfDataPoints = this.ItemsSource as List<DataPoint>;
if (sourceAsListOfDataPoints != null)
{
this.itemsSourcePoints = sourceAsListOfDataPoints;
this.ownsItemsSourcePoints = false;
return;
}
this.ClearItemsSourcePoints();
var sourceAsEnumerableDataPoints = this.ItemsSource as IEnumerable<DataPoint>;
if (sourceAsEnumerableDataPoints != null)
{
this.itemsSourcePoints.AddRange(sourceAsEnumerableDataPoints);
return;
}
// Get DataPoints from the items in ItemsSource
// if they implement IDataPointProvider
// If DataFields are set, this is not used
if (this.DataFieldX == null || this.DataFieldY == null)
{
foreach (var item in this.ItemsSource)
{
if (item is DataPoint)
{
this.itemsSourcePoints.Add((DataPoint)item);
continue;
}
var idpp = item as IDataPointProvider;
if (idpp == null)
{
continue;
}
this.itemsSourcePoints.Add(idpp.GetDataPoint());
}
}
else
{
var filler = new ListBuilder<DataPoint>();
filler.Add(this.DataFieldX, double.NaN);
filler.Add(this.DataFieldY, double.NaN);
filler.Fill(this.itemsSourcePoints, this.ItemsSource, args => new DataPoint(Axes.Axis.ToDouble(args[0]), Axes.Axis.ToDouble(args[1])));
}
}
public static object CreateInstance(Type type, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes)
{
if (type == null)
throw new ArgumentNullException(nameof(type));
// If they didn't specify a lookup, then we will provide the default lookup.
const BindingFlags LookupMask = (BindingFlags)0x000000FF;
if ((bindingAttr & LookupMask) == 0)
bindingAttr |= BindingFlags.Instance | BindingFlags.Public | BindingFlags.CreateInstance;
if (activationAttributes != null && activationAttributes.Length > 0)
throw new NotSupportedException(SR.NotSupported_ActivAttr);
type = type.UnderlyingSystemType;
CreateInstanceCheckType(type);
if (args == null)
args = Array.Empty<object>();
int numArgs = args.Length;
// This short-circuit depends on the fact that the toolchain prohibits valuetypes with nullary constructors. Unfortunately, we can't check for the presence of nullary
// constructors without risking a MissingMetadataException, and we can't regress the prior N behavior that allowed CreateInstance on valuetypes to work regardless of metadata.
if (numArgs == 0 && type.IsValueType)
return RuntimeAugments.NewObject(type.TypeHandle);
Type[] argTypes = new Type[numArgs];
for (int i = 0; i < numArgs; i++)
{
argTypes[i] = args[i]?.GetType();
}
ConstructorInfo[] candidates = type.GetConstructors(bindingAttr);
ListBuilder<MethodBase> matches = new ListBuilder<MethodBase>(candidates.Length);
for (int i = 0; i < candidates.Length; i++)
{
if (candidates[i].QualifiesBasedOnParameterCount(bindingAttr, CallingConventions.Any, argTypes))
matches.Add(candidates[i]);
}
if (matches.Count == 0)
throw new MissingMethodException(SR.Arg_NoDefCTor);
if (binder == null)
binder = Type.DefaultBinder;
object state = null;
MethodBase invokeMethod = binder.BindToMethod(bindingAttr, matches.ToArray(), ref args, null, culture, null, out state);
if (invokeMethod.GetParametersNoCopy().Length == 0)
{
if (args.Length != 0)
{
Debug.Assert((invokeMethod.CallingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs);
throw new NotSupportedException(SR.NotSupported_CallToVarArg);
}
// Desktop compat: CoreClr invokes a "fast-path" here (call Activator.CreateInstance(type, true)) that also
// bypasses the binder.ReorderArgumentArray() call. That "fast-path" isn't a fast-path for us so we won't do that
// but we'll still null out the "state" variable to bypass the Reorder call.
//
// The only time this matters at all is if (1) a third party binder is being used and (2) it actually reordered the array
// which it shouldn't have done because (a) we didn't request it to bind arguments by name, and (b) it's kinda hard to
// reorder a zero-length args array. But who knows what a third party binder will do if we make a call to it that we didn't
// used to do, so we'll preserve the CoreClr order of calls just to be safe.
state = null;
}
object result = ((ConstructorInfo)invokeMethod).Invoke(bindingAttr, binder, args, culture);
if (state != null)
binder.ReorderArgumentArray(ref args, state);
return result;
}
/// <summary>
/// Updates the data.
/// </summary>
protected internal override void UpdateData()
{
if (this.ItemsSource == null)
{
return;
}
this.slices.Clear();
var filler = new ListBuilder<PieSlice>();
filler.Add(this.LabelField, (string)null);
filler.Add(this.ValueField, double.NaN);
filler.Add(this.ColorField, OxyColors.Automatic);
filler.Add(this.IsExplodedField, false);
filler.FillT(
this.slices,
this.ItemsSource,
args =>
new PieSlice((string)args[0], Convert.ToDouble(args[1]))
{
Fill = (OxyColor)args[2],
IsExploded = (bool)args[3]
});
}
/// <summary>
/// Updates the data.
/// </summary>
protected internal override void UpdateData()
{
if (this.ItemsSource != null)
{
this.Items.Clear();
var filler = new ListBuilder<IntervalBarItem>();
filler.Add(this.MinimumField, double.NaN);
filler.Add(this.MaximumField, double.NaN);
filler.FillT(this.Items, this.ItemsSource, args => new IntervalBarItem() { Start = Convert.ToDouble(args[0]), End = Convert.ToDouble(args[1]) });
}
}
/// <summary>
/// Updates the data.
/// </summary>
protected internal override void UpdateData()
{
if (this.ItemsSource == null)
{
return;
}
this.items.Clear();
// Use the mapping to generate the points
if (this.Mapping != null)
{
foreach (var item in this.ItemsSource)
{
this.items.Add(this.Mapping(item));
}
return;
}
var sequenceOfHighLowItems = this.ItemsSource as IEnumerable<HighLowItem>;
if (sequenceOfHighLowItems != null)
{
this.items.AddRange(sequenceOfHighLowItems);
return;
}
var filler = new ListBuilder<HighLowItem>();
filler.Add(this.DataFieldX, double.NaN);
filler.Add(this.DataFieldHigh, double.NaN);
filler.Add(this.DataFieldLow, double.NaN);
filler.Add(this.DataFieldOpen, double.NaN);
filler.Add(this.DataFieldClose, double.NaN);
filler.FillT(this.items, this.ItemsSource, args => new HighLowItem(Axis.ToDouble(args[0]), Convert.ToDouble(args[1]), Convert.ToDouble(args[2]), Convert.ToDouble(args[3]), Convert.ToDouble(args[4])));
}
/// <summary>
/// The update data.
/// </summary>
protected internal override void UpdateData()
{
base.UpdateData();
if (this.ItemsSource == null)
{
this.IsPoints2Defined = this.points2.Count > 0;
if (this.IsPoints2Defined)
{
this.actualPoints2 = this.points2;
}
else
{
this.actualPoints2 = this.GetConstantPoints2().ToList();
}
return;
}
this.itemsSourcePoints2.Clear();
// TODO: make it consistent with DataPointSeries.UpdateItemsSourcePoints
// Using reflection on DataFieldX2 and DataFieldY2
this.IsPoints2Defined = this.DataFieldX2 != null && this.DataFieldY2 != null;
if (this.IsPoints2Defined)
{
var filler = new ListBuilder<DataPoint>();
filler.Add(this.DataFieldX2, double.NaN);
filler.Add(this.DataFieldY2, double.NaN);
filler.Fill(this.itemsSourcePoints2, this.ItemsSource, args => new DataPoint(Axes.Axis.ToDouble(args[0]), Axes.Axis.ToDouble(args[1])));
}
else
{
this.itemsSourcePoints2.AddRange(this.GetConstantPoints2());
}
}
