private IValueContainerFactory GetParametersContainerFactory(MethodInfo methodInfo)
{
var parameters = methodInfo.GetParameters();
return(ValueContainerFactory.GetFactory(
parameters.Select(p => new KeyValuePair <string, Type>(p.Name, p.ParameterType))));
}
public static T Deserialize <T>(this ISerializer serializer, Stream stream) where T : new()
{
// Need to be 'object', because T can be a value type.
object target = new T();
var propertySet =
typeof(IValueContainer).IsAssignableFrom(typeof(T))
? (IValueContainer)target
: ValueContainerFactory.CreateProxy(target);
using (stream)
serializer.Populate(stream, propertySet);
return((T)target);
}
private IValueContainerProxyFactory CreateFactory(Type serviceType)
{
var metadata = _serviceStateMetadataProvider.GetMetadata(serviceType);
if (metadata.Variables.Length == 0)
{
return(_emptyValueContainerProxyFactory);
}
var stateMembers = metadata.Variables.Select(
v => new KeyValuePair <string, MemberInfo>(v.Name, v.Field));
return(ValueContainerFactory.GetProxyFactory(serviceType, stateMembers));
}
private void WriteWatchDogForMachine()
{
const int maxValue = 32000;
const string watchDogFqn = @"{OPCV1}{TESTOPC}{storage.numeric.reg01}";
var tokenResolver = this._ServiceManager.DriversContextRepository.TokenResolver;
var watchDogToken = (ResolvedToken)tokenResolver.Resolve(watchDogFqn);
if (watchDogToken == null || !watchDogToken.IsSolved)
{
this._ServiceManager.AppendMessageToLog(MessageLevel.Warning, LOGGERSOURCE,
"WriteWatchDogForMachine(): token not solved");
return;
}
if (watchDogToken.Address.Device.Connector.State != DriverConnectionState.Connected)
{
this._ServiceManager.AppendMessageToLog(MessageLevel.Diagnostics, LOGGERSOURCE,
"WriteWatchDogForMachine(): device not connected");
return;
}
var valueToWrite = 0;
if (watchDogToken.Address.HasConsistentValue)
{
var watchDogValue = watchDogToken.Address.CurrentValue.GetConvertedValueToType <int>();
if (watchDogValue < maxValue)
{
valueToWrite = watchDogValue + 1;
}
}
/*
* NB: necessario PER ORA referenziare anche Atys.PowerDvc.Internals.dll
* per poter utilizzare ValueContainerFactory
* Questo meccanismo verrà variato nelle prossime versioni
*
*/
var writeValueContainer = ValueContainerFactory.GetSpecificValueContainer(watchDogToken.Address.ValueType, valueToWrite);
var writeRes = watchDogToken.Address.SetOutputValue(writeValueContainer);
this._ServiceManager.AppendMessageToLog(MessageLevel.Info, LOGGERSOURCE,
"WriteWatchDogForMachine(): write watchDogValue = {0} (val = {1})",
writeRes, valueToWrite);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
if (reader.TokenType == JsonToken.StartObject)
{
var content = new StringBuilder();
var textWriter = new StringWriter(content);
var jsonWriter = new JsonTextWriter(textWriter);
jsonWriter.WriteToken(reader, writeChildren: true);
return(new SerializedValueContainer(JsonSerializerAdapterFactory.FormatName, content.ToString(), null,
(format, form, state) =>
{
if (objectType == typeof(IValueContainer))
{
JObject jObj;
using (var stringReader = new StringReader((string)form))
{
jObj = (JObject)serializer.Deserialize(stringReader, typeof(JObject));
}
var container = ValueContainerFactory.Create(
((IEnumerable <KeyValuePair <string, JToken> >)jObj)
.ToDictionary(p => p.Key, p => GetType(p.Value.Type)));
for (var i = 0; i < container.GetCount(); i++)
{
var value = typeof(Newtonsoft.Json.Linq.Extensions).GetMethods().First(m => m.Name == "Value" && m.GetGenericArguments().Length == 1).MakeGenericMethod(container.GetType(i)).Invoke(null, new object[] { jObj[container.GetName(i)] });
container.SetValue(i, value);
}
return container;
}
else
{
throw new NotImplementedException();
}
return null;
}));
}
else
{
throw new InvalidOperationException(
$"Cannot pasre the JSON envelope - unexpected JSON token '{reader.TokenType}'.");
}
}
private static IValueContainerProxyFactory GetKeysProxyFactory(IEntityType entityType)
{
var pk = FindPrimaryKey(entityType);
if (pk == null)
{
return(null);
}
var pkProps = new List <KeyValuePair <string, MemberInfo> >();
foreach (var prop in pk.Properties)
{
pkProps.Add(new KeyValuePair <string, MemberInfo>(
prop.Name, (MemberInfo)prop.FieldInfo ?? prop.PropertyInfo));
}
return(ValueContainerFactory.GetProxyFactory(entityType.ClrType, pkProps));
}
internal static object CreateDeserializationTarget(Type objectType, out IValueContainer valueContainer)
{
if (objectType == null || objectType == typeof(IValueContainer))
{
valueContainer = new ValueContainer.ValueContainer();
return(valueContainer);
}
object target = Activator.CreateInstance(objectType);
if (typeof(IValueContainer).IsAssignableFrom(objectType))
{
valueContainer = (IValueContainer)target;
}
else
{
valueContainer = ValueContainerFactory.CreateProxy(target);
}
return(target);
}
private void Initialize()
{
foreach (var pair in _knownDbContextSet.TypesAndModels)
{
var dbContextType = pair.Key;
var model = pair.Value;
foreach (var entityType in model.GetEntityTypes())
{
if (entityType.ClrType == null)
{
continue;
}
foreach (var interfaceType in entityType.ClrType.GetInterfaces())
{
if (Projection.IsProjectionInterface(interfaceType))
{
var propertyNames = new HashSet <string>(interfaceType.GetProperties().Select(p => p.Name));
var valuesProxyFactoryForClrType = ValueContainerFactory.GetProxyFactory(
entityType.ClrType,
entityType.ClrType.GetProperties()
.Where(p => propertyNames.Contains(p.Name))
.Select(p => new KeyValuePair <string, MemberInfo>(p.Name, p)));
_projectionTypes.Add(interfaceType, valuesProxyFactoryForClrType);
var projectionType = Projection.GetProjectionType(interfaceType);
var valuesProxyFactoryForProjectionType = ValueContainerFactory.GetProxyFactory(
projectionType,
projectionType.GetProperties()
.Select(p => new KeyValuePair <string, MemberInfo>(p.Name, p)));
_projectionTypes.Add(projectionType, valuesProxyFactoryForProjectionType);
}
}
}
}
}
public IValueContainer CreatePropertySet(Type type)
{
#warning Optimize it
var instance = Activator.CreateInstance(type);
return(ValueContainerFactory.CreateProxy(instance));
}
public IValueContainer Decompose(object value)
{
return(ValueContainerFactory.CreateProxy(value));
}
