public static string GetSignature(this System.Reflection.PropertyInfo property, bool isSet)
{
string result = "";
var parameters = property.GetIndexParameters();
bool first = true;
foreach (var parameter in parameters)
{
if (!first)
{
result += ", ";
}
result += parameter.ParameterType.ToParameterTypeName() + parameter.GetName();
first = false;
}
if (isSet)
{
if (!first)
{
result += ", ";
}
result += property.PropertyType.ToParameterTypeName() + " value";
}
return(result);
}
public static string MakeCppIndexObjectCode(System.Reflection.PropertyInfo pi, int index, string strCName)
{
//FRPC_TestRPC ^ RPCGet_Child0(PackageWriter ^ pkg);
//{
// pkg->PushStack(0);
// return mChild0;
//}
string strCall = "";
string strArgSerial = "";
string strFullTypeName = pi.PropertyType.Namespace + ".H_" + pi.PropertyType.Name;
System.Reflection.ParameterInfo[] parameters = pi.GetIndexParameters();
for (int i = 0; i < parameters.Length; i++)
{
strCall += "," + CSharp2CppType(parameters[i].ParameterType.FullName) + " " + parameters[i].Name;
strArgSerial += TabStr + TabStr + "pkg.Write(" + parameters[i].Name + ");" + EndLine;
}
string strOut = "";
strOut += TabStr + CSharp2CppType(strFullTypeName) + "* " + strCName + "::HIndex_" + pi.Name + "(CppRPC::PackageWriter& pkg" + strCall + ")" + EndLine;
strOut += TabStr + "{" + EndLine;
strOut += TabStr + TabStr + "pkg.PushStack(11+" + index + ");" + EndLine;
strOut += strArgSerial;
strOut += TabStr + TabStr + "return " + CSharp2CppType(strFullTypeName) + "::smInstance();" + EndLine;
strOut += TabStr + "}" + EndLine;
return(strOut);
}
public IParameter[] GetParameters()
{
if (null == _parameters)
{
_parameters = _typeSystemServices.Map(_property.GetIndexParameters());
}
return(_parameters);
}
public PropertyInfo(TypeInfo type, System.Reflection.PropertyInfo propertyInfo, XElement xmlDocs)
{
Type = type;
Property = propertyInfo;
IndexParameters = propertyInfo.GetIndexParameters().ToList();
}
public static System.UInt32 GetIndexerHashCode(System.Reflection.PropertyInfo pi, System.String cname)
{
System.String hashString = cname + "$" + pi.PropertyType.FullName + " " + pi.Name + "(";
System.Reflection.ParameterInfo[] parameters = pi.GetIndexParameters();
for (int i = 0; i < parameters.Length; i++)
{
hashString += parameters[i].ParameterType.FullName + " " + parameters[i].Name + ",";
}
hashString += ")";
return(ServerFrame.UniHash.DefaultHash(hashString));// (System.UInt32)hashString.GetHashCode();
}
//TODO: Поговорить с Ваней на тему того, чтобы разместить храилища функций, свойств и т.д. в этих классах. Тогда конструкторы можно будет сделать закрытыми.
/// <summary>
/// Конструктор класса.
/// </summary>
/// <param name="prop_info">Оборачиваемое свойство.</param>
public compiled_property_node(System.Reflection.PropertyInfo prop_info)
{
_pi = prop_info;
System.Reflection.ParameterInfo[] pas = _pi.GetIndexParameters();
if ((pas != null) && (pas.Length > 0))
{
foreach (System.Reflection.ParameterInfo parinfo in pas)
{
parameters.AddElement(new compiled_parameter(parinfo));
}
}
}
private static bool IsIndexer(PropertyInfo propertyInfo)
{
if (propertyInfo == null)
{
throw new ArgumentNullException("propertyInfo");
}
var indexParameters = propertyInfo.GetIndexParameters();
return(indexParameters != null &&
indexParameters.Length > 0 &&
indexParameters[0].ParameterType == typeof(string));
}
public static PropertyName FromPropertyInfo(System.Reflection.PropertyInfo property)
{
if (property == null)
{
throw new ArgumentNullException("property");
}
var declaringType = TypeName.FromType(property.DeclaringType);
var propertyType = TypeName.FromType(property.PropertyType);
var parms = ParameterData.ConvertAll(property.GetIndexParameters());
return(new PropertyName(declaringType, property.Name, propertyType, parms));
}
public void System_PropertyInfo_GetIndexParameters_is_wrapped_by_Routine_PropertyInfo()
{
propertyInfo = typeof(TestClass_OOP).GetProperty("Item");
testing = type.of <TestClass_OOP>().GetProperty("Item");
var expected = propertyInfo.GetIndexParameters();
var actual = testing.GetIndexParameters();
foreach (var parameter in actual)
{
Assert.IsTrue(expected.Any(p => p.ParameterType == parameter.ParameterType.GetActualType()), $"{parameter.Name} was not expected in index parameters of {propertyInfo}");
}
foreach (var parameter in expected)
{
Assert.IsTrue(actual.Any(p => p.ParameterType.GetActualType() == parameter.ParameterType), $"{parameter.Name} was expected in index parameters of {propertyInfo}");
}
}
private static System.Xml.XmlNode MakePropertyNode(System.Reflection.PropertyInfo memberInfo,
System.Xml.XmlDocument ownerdoc)
{
System.Xml.XmlNode nodeMember;
nodeMember = Utility.xmlHelpers.NewElement(ownerdoc, "Property", memberInfo.Name);
nodeMember.Attributes.Append(Utility.xmlHelpers.NewAttribute(ownerdoc, "Type", memberInfo.PropertyType.ToString()));
nodeMember.Attributes.Append(Utility.xmlHelpers.NewBoolAttribute(ownerdoc, "CanRead", memberInfo.CanRead));
nodeMember.Attributes.Append(Utility.xmlHelpers.NewBoolAttribute(ownerdoc, "CanWrite", memberInfo.CanWrite));
MakeParameterNodes(nodeMember, memberInfo.GetIndexParameters());
if (memberInfo.GetGetMethod() != null)
{
nodeMember.AppendChild(MakeMethodNode(memberInfo.GetGetMethod(), ownerdoc, false));
}
if (memberInfo.GetSetMethod() != null)
{
nodeMember.AppendChild(MakeMethodNode(memberInfo.GetSetMethod(), ownerdoc, false));
}
return(nodeMember);
}
private static bool IsIndexer(PropertyInfo propertyInfo)
{
if (propertyInfo == null)
throw new ArgumentNullException("propertyInfo");
var indexParameters = propertyInfo.GetIndexParameters();
return indexParameters != null
&& indexParameters.Length > 0
&& indexParameters[0].ParameterType == typeof(string);
}
public static string MakeIndexerExecuterCode(System.Reflection.PropertyInfo pi, TreeNode node, bool bIsClient)
{
string fullname = "";
int LimitLevel = 0;
if (bIsClient)
{
fullname = node.Name;
}
else
{
RPC.RPCClassAttribute ClassAttr = node.Tag as RPC.RPCClassAttribute;
fullname = ClassAttr.RPCType.FullName;
object[] propAttrs = pi.GetCustomAttributes(typeof(RPC.RPCIndexObjectAttribute), false);
if (propAttrs != null && propAttrs.Length == 1)
{
RPC.RPCIndexObjectAttribute propAtt = propAttrs[0] as RPC.RPCIndexObjectAttribute;
if (propAtt != null)
{
LimitLevel = propAtt.LimitLevel;
}
}
}
string strOut = "";
strOut += "[RPC.RPCIndexExecuterTypeAttribute(" + RPC.RPCEntrance.GetIndexerHashCode(pi, fullname) + ",\"" + pi.Name + "\",typeof(HIndex_" + RPC.RPCEntrance.GetIndexerHashCode(pi, fullname) + "))]" + EndLine;
strOut += "public class HIndex_" + RPC.RPCEntrance.GetIndexerHashCode(pi, fullname) + ": RPC.RPCIndexerExecuter" + EndLine;
strOut += "{" + EndLine;
strOut += TabStr + "public override int LimitLevel" + EndLine;
strOut += TabStr + "{" + EndLine;
strOut += TabStr + TabStr + "get { return " + LimitLevel + "; }" + EndLine;
strOut += TabStr + "}" + EndLine;
strOut += TabStr + "public override RPC.RPCObject Execute(RPC.RPCObject obj,RPC.PackageProxy pkg)" + EndLine;
strOut += TabStr + "{" + EndLine;
strOut += TabStr + TabStr + fullname + " host = obj as " + fullname + ";" + EndLine;
strOut += TabStr + TabStr + "if (host == null) return null;" + EndLine;
string strCall = "";
System.Reflection.ParameterInfo[] parameters = pi.GetIndexParameters();
for (int i = 0; i < parameters.Length; i++)
{
bool isNew = false;
Type baseType = parameters[i].ParameterType;
while (!isNew)
{
baseType = baseType.BaseType;
if (baseType == null)
{
break;
}
if (baseType.Name == "IAutoSaveAndLoad")
{
isNew = true;
break;
}
}
if (isNew)
{
strOut += TabStr + TabStr + parameters[i].ParameterType.FullName + " " + parameters[i].Name + " = new " + parameters[i].ParameterType.FullName + "();" + EndLine;
strOut += TabStr + TabStr + "pkg.Read( " + parameters[i].Name + ");" + EndLine;
}
else
{
strOut += TabStr + TabStr + parameters[i].ParameterType.FullName + " " + parameters[i].Name + ";" + EndLine;
strOut += TabStr + TabStr + "pkg.Read(out " + parameters[i].Name + ");" + EndLine;
}
if (i == parameters.Length - 1)
{
strCall += parameters[i].Name;
}
else
{
strCall += parameters[i].Name + ",";
}
}
strOut += TabStr + TabStr + "return host[" + strCall + "];" + EndLine;
strOut += TabStr + "}" + EndLine;
strOut += "}" + EndLine;
return(strOut);
}
/// <summary>
/// Writes an object out to the SocketReporter, using reflection to obtain all fields and properties.
/// </summary>
/// <param name="prefix">String prefixed before each line of text.</param>
/// <param name="o">The object to dump</param>
/// <param name="name">A name that will be used to label the dump</param>
/// <param name="PropertiesOnly">If true, only properties are dumped. If false, both fields and properties are dumped.</param>
/// <param name="recurse">Recurse on the given field/property names </param>
/// <remarks>How to make it easy to automatically handle objects inside?</remarks>
public void WriteObject(string prefix, string name, object o, bool PropertiesOnly, string[] recurse)
{
string oldPrefix = SetPrefix(prefix);
try
{
if (o == null)
{
WriteLine("Dumping {0}: [null reference]", name);
return;
}
WriteLine("Dumping {0} ['{1}', hashcode {2}]", name, o.ToString(), o.GetHashCode());
System.Reflection.MemberInfo[] MemberList = o.GetType().GetMembers(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic); // what, you don't have a 10-foot-wide screen to view this code on?
// this method was copied from the SocketReporter class
// however, under 2.0, the WTFery I needed for suitable sorting can go away
Array.Sort <System.Reflection.MemberInfo>(
MemberList,
delegate(System.Reflection.MemberInfo a, System.Reflection.MemberInfo b)
{
return(a.Name.CompareTo(b.Name));
}
);
//Array.Sort(MemberList, new MemberInfoSorter());
StringBuilder output = new StringBuilder();
foreach (System.Reflection.MemberInfo mi in MemberList)
{
// Only proceed if this is a field (and we are allowed to dump fields),
// or if this is a
if (!(
(mi.MemberType == System.Reflection.MemberTypes.Field && !PropertiesOnly) ||
(mi.MemberType == System.Reflection.MemberTypes.Property)
))
{
continue;
}
output.AppendFormat("\t");
// if it was inherited, prepend the type
if (mi.DeclaringType != null &&
mi.DeclaringType != o.GetType())
{
output.AppendFormat("{0}.", mi.DeclaringType.Name);
}
output.AppendFormat("{0} = ", mi.Name);
bool dontdumpvalue = false;
object val = null;
if (mi.MemberType == System.Reflection.MemberTypes.Field)
{
System.Reflection.FieldInfo fi = (System.Reflection.FieldInfo)mi;
val = fi.GetValue(o);
}
else
{
System.Reflection.PropertyInfo pi = (System.Reflection.PropertyInfo)mi;
if (pi.GetIndexParameters().Length > 0)
{
output.Append("(cannot dump indexed property)");
dontdumpvalue = true;
}
else if (!pi.CanRead)
{
output.Append("WTF? Write-only property?!?");
dontdumpvalue = true;
}
else
{
try
{
val = pi.GetValue(o, null);
}
catch (System.Reflection.TargetInvocationException tiex)
{
Exception realex = tiex.InnerException;
if (realex == null)
{
throw; // redmond, we have a problem
}
output.AppendFormat("[{0}: {1}]", realex.GetType(), realex.Message);
dontdumpvalue = true;
}
}
}
if (!dontdumpvalue)
{
if (val == null)
{
output.Append("null");
}
else if (val.GetType().IsPrimitive) // true for Booleans and builtin numeric types
{
output.Append(val.ToString());
}
else
{
// do some heuristics to determine if ToString() does anything special.
System.Reflection.MethodInfo tostr = val.GetType().GetMethod("ToString", new Type[] { });
if (tostr.DeclaringType == typeof(object))
{
// Since we're using the standard ToString() implementation, it must be a regular object.
output.AppendFormat("{{{0}}}", val.ToString());
}
else
{
output.AppendFormat("'{0}'", val.ToString());
}
}
output.Append("\r\n");
if (((IList)recurse).Contains(mi.Name)) // recurse into this guy?
{
Write(output.ToString()); // flush the output
output = new StringBuilder();
WriteObject(prefix + ">",
string.Format("{0}.{1}", name, mi.Name),
val,
PropertiesOnly,
new string[] { });
}
}
}
Write(output.ToString());
}
finally
{
SetPrefix(oldPrefix);
}
}
/// <summary>
/// 添加设置对象属性值的撤销信息
/// </summary>
/// <param name="PropertyName">属性名称,不区分大小写</param>
/// <param name="OldValue">旧的属性值</param>
/// <param name="NewValue">新的属性值</param>
/// <param name="ObjectInstance">对象实例</param>
public void AddProperty(
string PropertyName,
object OldValue,
object NewValue,
object ObjectInstance)
{
if (PropertyName == null || PropertyName.Length == 0)
{
throw new System.ArgumentNullException("PropertyName");
}
if (ObjectInstance == null)
{
throw new System.ArgumentNullException("ObjectInstance");
}
System.Type t = ObjectInstance.GetType();
System.Reflection.PropertyInfo p = t.GetProperty(
PropertyName,
System.Reflection.BindingFlags.IgnoreCase |
System.Reflection.BindingFlags.Instance |
System.Reflection.BindingFlags.Public);
if (p == null)
{
throw new System.Exception(string.Format(WriterStrings.MissProperty_Name, PropertyName));
}
System.Reflection.ParameterInfo[] ps = p.GetIndexParameters();
if (ps != null && ps.Length > 0)
{
throw new System.Exception(string.Format(WriterStrings.PropertyCannotHasParameter_Name, PropertyName));
}
if (p.CanWrite == false)
{
throw new System.Exception(string.Format(WriterStrings.PropertyIsReadonly_Name, PropertyName));
}
Type pt = p.PropertyType;
if (OldValue != null)
{
Type vt = OldValue.GetType();
if (vt.Equals(pt) == false && vt.IsSubclassOf(pt) == false)
{
throw new System.Exception("旧数据值类型不匹配");
}
}
if (NewValue != null)
{
Type vt = NewValue.GetType();
if (vt.Equals(pt) == false && vt.IsSubclassOf(pt) == false)
{
throw new System.Exception("新数值类型不匹配");
}
}
XTextUndoNameProperty undo = new XTextUndoNameProperty();
undo.Document = myDocument;
undo.Property = p;
undo.InGroup = true;
undo.OldValue = OldValue;
undo.NewValue = NewValue;
undo.ObjectInstance = ObjectInstance;
this.Add(undo);
}
//TODO: Поговорить с Ваней на тему того, чтобы разместить храилища функций, свойств и т.д. в этих классах. Тогда конструкторы можно будет сделать закрытыми.
/// <summary>
/// Конструктор класса.
/// </summary>
/// <param name="prop_info">Оборачиваемое свойство.</param>
public compiled_property_node(System.Reflection.PropertyInfo prop_info)
{
_pi=prop_info;
System.Reflection.ParameterInfo[] pas = _pi.GetIndexParameters();
if ((pas != null) && (pas.Length > 0))
{
foreach (System.Reflection.ParameterInfo parinfo in pas)
{
parameters.AddElement(new compiled_parameter(parinfo));
}
}
}