public override object GetValue(object obj, object[] index)
{
object result = null;
//always obj == Owner
Component_InvokeMember c = (Component_InvokeMember)obj;
//!!!!так?
if (invoke && !c.FlowSupport)
{
c.Invoke();
}
object value;
if (c.propertyValues.TryGetValue(Signature, out value))
{
//update value for Reference type
if (referenceSupport)
{
//convert from ReferenceNoValue
if (value != null && value is ReferenceNoValue)
{
value = ReferenceUtility.MakeReference(ReferenceUtility.GetUnreferencedType(Type.GetNetType()), ((ReferenceNoValue)value).GetByReference);
}
IReference iReference = value as IReference;
if (iReference != null)
{
//!!!!try catch? где еще так
//get value by reference
//!!!!
value = iReference.GetValue(obj);
//value = iReference.GetValue( Owner );
//!!!!?
if (!ReadOnly) //!!!!new
{
//!!!!
SetValue(obj, value, Indexers);
//SetValue( Owner, value, Indexers );
}
}
}
result = value;
}
//check the type. result can contains value with another type after change the type of property.
if (result != null && !Type.IsAssignableFrom(MetadataManager.MetadataGetType(result)))
{
result = null;
}
if (result == null && Type.GetNetType().IsValueType)
{
result = Type.InvokeInstance(null);
}
return(result);
}
void Update()
{
if (needUpdate)
{
//!!!!slowly?
var demandedReturnType = GetDemandedReturnType();
if (demandedReturnType != createdPropertyReturnType || property == null)
{
Clear();
if (Enabled) //!!!!?
{
needUpdate = false;
if (demandedReturnType != null)
{
//!!!!TypeInfo?
Type unrefNetType = ReferenceUtility.GetUnreferencedType(demandedReturnType.GetNetType());
var type = MetadataManager.GetTypeOfNetType(unrefNetType);
//!!!!
var typeUnreferenced = type;
var p = new PropertyImpl(this, "Output", false, type, typeUnreferenced, new Metadata.Parameter[0], true, "Parameter", false);
p.Description = "";
property = p;
createdPropertyReturnType = demandedReturnType;
}
}
}
}
}
public void Update()
{
if (DisableUpdate)
{
return;
}
//check disabled
if (!Enabled)
{
Clear();
return;
}
var newCode = Code.Value;
needUpdate = false;
if (newCode == compiledCode)
{
return;
}
////check for updates
//if( !needUpdate && newCode != compiledCode )
// needUpdate = true;
////nothing to update
//if( !needUpdate )
// return;
//do update
Clear();
compiledCode = newCode;
needUpdate = false;
if (!string.IsNullOrEmpty(newCode))
{
compiledScript = ScriptingCSharpEngine.GetOrCompileScript(compiledCode, out var error);
if (!string.IsNullOrEmpty(error))
{
Log.Warning($"Unable to compile script.\r\n\r\nComponent \"{GetPathFromRoot( true )}\".\r\n\r\n" + error);
return;
}
CreateScriptInstance();
//fields
foreach (var netField in compiledScript.Fields)
{
if (netField.IsPublic && netField.Name != "Owner")
{
var type = MetadataManager.GetTypeOfNetType(netField.FieldType);
var member = new PropertyImpl(this, netField.Name, netField.IsStatic, type, type, Array.Empty <Metadata.Parameter>(), false, compiledScript, netField);
compiledMembers.Add(member);
compiledMemberBySignature[member.Signature] = member;
}
}
//properties
foreach (var netProperty in compiledScript.Properties)
{
if (netProperty.GetMethod != null && netProperty.GetMethod.IsPublic)
{
var type = MetadataManager.GetTypeOfNetType(netProperty.PropertyType);
var unrefType = ReferenceUtility.GetUnreferencedType(type);
var netParameters = netProperty.GetIndexParameters();
var indexers = new List <Metadata.Parameter>();
for (int n = 0; n < netParameters.Length; n++)
{
var netParam = netParameters[n];
var netType = netParam.ParameterType;
bool isByReference = netType.IsByRef;
if (isByReference)
{
netType = netType.GetElementType();
}
var type2 = MetadataManager.GetTypeOfNetType(netType);
var p = new Metadata.Parameter(netParam.Name, type2, isByReference, netParam.IsIn, netParam.IsOut, netParam.IsRetval,
netParam.IsOptional, netParam.HasDefaultValue, netParam.DefaultValue);
indexers.Add(p);
}
var member = new PropertyImpl(this, netProperty.Name, ReflectionUtility.PropertyIsStatic(netProperty), type, unrefType, indexers.Count != 0 ? indexers.ToArray() : Array.Empty <Metadata.Parameter>(), !netProperty.CanWrite, compiledScript, netProperty);
compiledMembers.Add(member);
compiledMemberBySignature[member.Signature] = member;
}
}
//methods
foreach (var netMethod in compiledScript.Methods)
{
if (netMethod.IsSpecialName)
{
if (netMethod.Name.Length > 4 && (netMethod.Name.Substring(0, 4) == "get_" || netMethod.Name.Substring(0, 4) == "set_"))
{
continue;
}
if (netMethod.Name.Length > 4 && netMethod.Name.Substring(0, 4) == "add_")
{
continue;
}
if (netMethod.Name.Length > 7 && netMethod.Name.Substring(0, 7) == "remove_")
{
continue;
}
}
if (netMethod.GetBaseDefinition() != netMethod)
{
continue;
}
var netParams = netMethod.GetParameters();
var parameters = new List <Metadata.Parameter>();
for (int n = 0; n < netParams.Length; n++)
{
var netParam = netParams[n];
var netType = netParam.ParameterType;
bool isByReference = netType.IsByRef;
if (isByReference)
{
netType = netType.GetElementType();
}
var type = MetadataManager.GetTypeOfNetType(netType);
var p = new Metadata.Parameter(netParam.Name, type, isByReference, netParam.IsIn, netParam.IsOut, netParam.IsRetval,
netParam.IsOptional, netParam.HasDefaultValue, netParam.DefaultValue);
parameters.Add(p);
}
if (netMethod.ReturnType != null && netMethod.ReturnType != typeof(void))
{
var netType = netMethod.ReturnType;
bool isRef = netType.IsByRef;
if (isRef)
{
netType = netType.GetElementType();
}
var paramType = MetadataManager.GetTypeOfNetType(netType);
//"_return"
var p = new Metadata.Parameter("ReturnValue", paramType, isRef, false, true, true, false, false, null);
parameters.Add(p);
}
bool isOperator = netMethod.IsSpecialName && netMethod.Name.Length > 3 && netMethod.Name.Substring(0, 3) == "op_";
var member = new MethodImpl(this, netMethod.Name, netMethod.IsStatic, parameters.ToArray(), false, isOperator, compiledScript, netMethod);
compiledMembers.Add(member);
compiledMemberBySignature[member.Signature] = member;
}
//One method mode
if (compiledScript != null && compiledMembers.Count == 1)
{
compiledOneMethod = (MethodImpl)compiledMembers[0];
OneMethod_AddProperties(compiledOneMethod);
//var parameters = new List<Metadata.Parameter>();
//parameters.Add( new Metadata.Parameter( "a", MetadataManager.GetTypeOfNetType( typeof( int ) ), false, true, false, false, false, false, null ) );
//parameters.Add( new Metadata.Parameter( "ReturnValue", MetadataManager.GetTypeOfNetType( typeof( int ) ), false, true, false, true, false, false, null ) );
//xx xx;
//var method = new MethodImpl( this, "Method", true, parameters.ToArray(), false, false, compiledScript, compiledScript.PublicMethods[ 0 ] );
//compiledMembers.Add( method );
//compiledMemberBySignature[ method.Signature ] = method;
//compiledOneMethod = method;
////create properties
//if( method != null )
//{
// //parameters
// propertyMethodParameters = new List<PropertyImpl>();
// for( int nParameter = 0; nParameter < method.Parameters.Length; nParameter++ )
// {
// var parameter = method.Parameters[ nParameter ];
// ////!!!!имя еще как-то фиксить?
// //string name = null;
// //!!!!
// //if( parameter.ReturnValue )
// // name = "ReturnValue";
// //if( name == null )
// var name = parameter.Name.Substring( 0, 1 ).ToUpper() + parameter.Name.Substring( 1 );
// //!!!!поддержать ByReference. еще какие?
// bool readOnly = parameter.Output || parameter.ReturnValue;
// //!!!!
// //var parameterType = GetOverrideParameterType( parameter, out bool error );
// //if( error )
// //{
// // unableToInit = true;
// // goto unableToInitLabel;
// //}
// //var parameterType = parameter.Type;
// Metadata.TypeInfo type;
// bool referenceSupport = !readOnly;
// if( referenceSupport )
// {
// Type unrefNetType = parameter.Type.GetNetType();
// var refNetType = typeof( Reference<> ).MakeGenericType( unrefNetType );
// type = MetadataManager.GetTypeOfNetType( refNetType );
// }
// else
// type = parameter.Type;
// bool invoke = parameter.ReturnValue || parameter.ByReference || parameter.Output;
// string namePrefix = "__parameter_";
// string displayName = TypeUtils.DisplayNameAddSpaces( name );
// var p = new PropertyImpl( this, namePrefix + name, false, type, parameter.Type, new Metadata.Parameter[ 0 ], readOnly, "Method's Parameters", displayName, referenceSupport, parameter, invoke );
// p.Description = "";
// if( !readOnly )
// p.Serializable = true;
// properties.Add( p );
// propertyBySignature[ p.Signature ] = p;
// //!!!!так? если несколько?
// if( parameter.ReturnValue )
// propertyMethodReturnParameter = p;
// else
// propertyMethodParameters.Add( p );
// }
//}
}
//update child handlers
try
{
foreach (var handler in GetComponents <Component_EventHandler>())
{
handler.UpdateSubscription();
}
}
catch { }
}
}
