public InteropManager(CompilerEnvironment env)
{
this.env = env;
rootEnv = env.Global.Environment();
attributeHelper = env.AttributeHelper;
typeRepresentationCache = new Map<CST.QualifiedTypeName, TypeRepresentation>();
}
public void Intercept(IInvocation invocation)
{
var attributeHelper = new AttributeHelper();
var methodHaveUnitOfWorkAttribute = attributeHelper.MethodDefinedAttribute<UnitOfWorkAttribute>(invocation);
if (!methodHaveUnitOfWorkAttribute)
{
invocation.Proceed();
return;
}
_unitOfWork.BeginTransaction();
invocation.Proceed();
_unitOfWork.Commit();
}
public static string GetContractReference(Type type)
{
var attribs = type.GetCustomAttributes(false);
var helper = new AttributeHelper(attribs);
var name = Maybe.String
.GetValue(() => helper.GetString<ProtoContractAttribute>(p => p.Name))
.GetValue(() => helper.GetString<DataContractAttribute>(p => p.Name))
.GetValue(() => helper.GetString<XmlTypeAttribute>(p => p.TypeName))
.GetValue(() => type.Name);
var ns = Maybe.String
.GetValue(() => helper.GetString<DataContractAttribute>(p => p.Namespace))
.GetValue(() => helper.GetString<XmlTypeAttribute>(p => p.Namespace))
.Convert(s => s.Trim() + "/", "");
return ns + name;
}
public static string GetContractReference(Type type)
{
var attribs = type.GetCustomAttributes(false);
var helper = new AttributeHelper(attribs);
var s1 = Optional<string>.Empty;
var name = s1
.Combine(() => helper.GetString("ProtoContractAttribute","Name"))
.Combine(() => helper.GetString("DataContractAttribute", "Name"))
.Combine(() => helper.GetString("XmlTypeAttribute", "TypeName"))
.GetValue(type.Name);
var ns = s1
.Combine(() => helper.GetString("DataContractAttribute", "Namespace"))
.Combine(() => helper.GetString("XmlTypeAttribute", "Namespace"))
.Convert(s => s.Trim() + "/", "");
ns = AppendNesting(ns, type);
return ns + name;
}
public static IEnumerable<CompletionPort> ReadBytesAsync(AsyncMachine<byte[]> machine, Stream stream, int length)
{
var attributeHelper = new AttributeHelper<VhdHeader>();
var buffer = new byte[length];
int readCount = 0;
int remaining = length;
while (remaining > 0)
{
stream.BeginRead(buffer, readCount, remaining, machine.CompletionCallback, null);
yield return CompletionPort.SingleOperation;
var currentRead = stream.EndRead(machine.CompletionResult);
if (currentRead == 0)
{
break;
}
readCount += currentRead;
remaining -= currentRead;
}
machine.ParameterValue = buffer;
yield break;
}
public IEnumerable<IConfigurationOptions> ParseXml(string contentsOfConfigFile)
{
if (String.IsNullOrEmpty(contentsOfConfigFile))
throw new ArgumentException("contentsOfConfigFile is null or empty.", "contentsOfConfigFile");
XmlDocument doc = new XmlDocument();
doc.LoadXml(contentsOfConfigFile);
XmlNodeList configNodes = doc.DocumentElement.SelectNodes("//config");
var result = new List<IConfigurationOptions>();
foreach (XmlNode configNode in configNodes)
{
IConfigurationOptions options = new DefaultConfigurationOptions();
var attrib = new AttributeHelper(".//add[@key='{0}']/@value", configNode);
options.AssemblyDirectory = attrib.Get("assemblydirectory");
options.AbstractBaseName = attrib.Get("abstractbasename");
options.BaseTypeName = attrib.Get("basetypename");
options.ConnectionString = attrib.Get("connectionstring");
options.DataNamespace = attrib.Get("datanamespace");
options.IocVerboseLogging = attrib.GetBool("iocverboselogging", false);
options.GenerateColumnList = attrib.GetBool("generatecolumnlist", true);
options.GenerateComments = attrib.GetBool("generatecomments", true);
options.UseMicrosoftsHeader = attrib.GetBool("usemicrosoftsheader", false);
options.Namespace = attrib.Get("namespace");
options.OutputPath = attrib.Get("outputpath");
options.EnumOutputPath = attrib.Get("enumoutputpath");
options.EnumNamespace = attrib.Get("enumnamespace");
options.StaticPrimaryKeyName = attrib.Get("staticprimarykeyname");
options.OnlyTablesWithPrefix.AddRange(attrib.Get("onlytableswithprefix").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries));
options.SkipTablesWithPrefix.AddRange(attrib.Get("skiptableswithprefix").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries));
options.SkipTables.AddRange(attrib.Get("skiptables").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries));
options.Enums = ParseEnums(configNode);
LoadEnumReplacements(configNode, options);
options.Components = ParseComponents(configNode);
result.Add(options);
}
return result;
}
public CoreFramework(string orgCode)
{
OrgCode = orgCode;
columnAttrList = AttributeHelper.GetEntityColumnAtrributes <TEntity>();
}
public virtual void CheckObjectLiteral(TypeDefinition type, ITranslator translator)
{
if (!this.IsObjectLiteral(type))
{
return;
}
var objectCreateMode = this.GetObjectCreateMode(type);
if (objectCreateMode == 0)
{
var ctors = type.GetConstructors();
foreach (var ctor in ctors)
{
foreach (var parameter in ctor.Parameters)
{
if (parameter.ParameterType.FullName == "Bridge.ObjectCreateMode")
{
TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_PLAIN_NO_CREATE_MODE_CUSTOM_CONSTRUCTOR, type);
}
if (parameter.ParameterType.FullName == "Bridge.ObjectInitializationMode")
{
continue;
}
TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_PLAIN_CUSTOM_CONSTRUCTOR, type);
}
}
}
if (type.IsInterface)
{
if (type.HasMethods && type.Methods.GroupBy(m => m.Name).Any(g => g.Count() > 1))
{
TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_INTERFACE_NO_OVERLOAD_METHODS, type);
}
if (type.HasEvents)
{
TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_INTERFACE_NO_EVENTS, type);
}
}
else
{
if (type.Methods.Any(m => !m.IsRuntimeSpecialName && m.Name.Contains(".") && !m.Name.Contains("<")) ||
type.Properties.Any(m => !m.IsRuntimeSpecialName && m.Name.Contains(".") && !m.Name.Contains("<")))
{
TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_INTERFACE_NO_EXPLICIT_IMPLEMENTATION, type);
}
}
if (type.BaseType != null)
{
TypeDefinition baseType = null;
try
{
baseType = type.BaseType.Resolve();
}
catch (Exception)
{
}
if (objectCreateMode == 1 && baseType != null && baseType.FullName != "System.Object" && baseType.FullName != "System.ValueType" && this.GetObjectCreateMode(baseType) == 0)
{
TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_CONSTRUCTOR_INHERITANCE, type);
}
if (objectCreateMode == 0 && baseType != null && this.GetObjectCreateMode(baseType) == 1)
{
TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_PLAIN_INHERITANCE, type);
}
}
if (type.Interfaces.Count > 0)
{
foreach (var @interface in type.Interfaces)
{
TypeDefinition iDef = null;
try
{
iDef = @interface.Resolve();
}
catch (Exception)
{
}
if (iDef != null && iDef.FullName != "System.Object" && !this.IsObjectLiteral(iDef))
{
TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_INTERFACE_INHERITANCE, type);
}
}
}
if (objectCreateMode == 0)
{
var hasVirtualMethods = false;
foreach (MethodDefinition method in type.Methods)
{
if (AttributeHelper.HasCompilerGeneratedAttribute(method))
{
continue;
}
if (method.IsVirtual && !(method.IsSetter || method.IsGetter))
{
hasVirtualMethods = true;
break;
}
}
if (hasVirtualMethods)
{
Bridge.Translator.TranslatorException.Throw(Constants.Messages.Exceptions.OBJECT_LITERAL_NO_VIRTUAL_METHODS, type);
}
}
}
public static string ResourceKey(this Enum enumValue)
{
return(AttributeHelper.GetAttributeValue <ResourceKeyAttribute, string>(enumValue));
}
public VhdParentLocatorFactory(VhdDataReader dataReader, long offset)
{
this.dataReader = dataReader;
this.offset = offset;
attributeHelper = new AttributeHelper<ParentLocator>();
}
public override CodeAttributeDeclaration GetAttributeDeclaration()
{
List <string> errorList = new List <string>();
if (!IsValid(errorList))
{
throw new ArgumentException(errorList[0]);
}
CodeAttributeDeclaration attribute = new CodeAttributeDeclaration("ValidateRange");
switch (_type)
{
case RangeValidationType.Integer:
if (!string.IsNullOrEmpty(_min))
{
attribute.Arguments.Add(AttributeHelper.GetPrimitiveAttributeArgument(int.Parse(_min)));
}
else
{
attribute.Arguments.Add(AttributeHelper.GetPrimitiveAttributeArgumentUsingSnippet("Int32.MinValue"));
}
if (!string.IsNullOrEmpty(_max))
{
attribute.Arguments.Add(AttributeHelper.GetPrimitiveAttributeArgument(int.Parse(_max)));
}
else
{
attribute.Arguments.Add(AttributeHelper.GetPrimitiveAttributeArgumentUsingSnippet("Int32.MaxValue"));
}
break;
case RangeValidationType.DateTime:
if (!string.IsNullOrEmpty(_min))
{
attribute.Arguments.Add(AttributeHelper.GetPrimitiveAttributeArgument(DateTime.Parse(_min)));
}
else
{
attribute.Arguments.Add(AttributeHelper.GetPrimitiveAttributeArgumentUsingSnippet("DateTime.MinValue"));
}
if (!string.IsNullOrEmpty(_max))
{
attribute.Arguments.Add(AttributeHelper.GetPrimitiveAttributeArgument(DateTime.Parse(_max)));
}
else
{
attribute.Arguments.Add(AttributeHelper.GetPrimitiveAttributeArgumentUsingSnippet("DateTime.MaxValue"));
}
break;
case RangeValidationType.String:
if (!string.IsNullOrEmpty(_min))
{
attribute.Arguments.Add(AttributeHelper.GetPrimitiveAttributeArgument(_min));
}
else
{
attribute.Arguments.Add(AttributeHelper.GetPrimitiveAttributeArgumentUsingSnippet("String.Empty"));
}
if (!string.IsNullOrEmpty(_max))
{
attribute.Arguments.Add(AttributeHelper.GetPrimitiveAttributeArgument(_max));
}
else
{
attribute.Arguments.Add(AttributeHelper.GetPrimitiveAttributeArgumentUsingSnippet("String.Empty"));
}
break;
default:
throw new ArgumentOutOfRangeException("Type");
}
base.AddAttributeArguments(attribute, ErrorMessagePlacement.UnOrdered);
return(attribute);
}
public static string StrName(this Enum enumValue)
{
var attrValue = AttributeHelper.GetAttributeValue <StringNameAttribute, string>(enumValue);
return(string.IsNullOrEmpty(attrValue) ? enumValue.ToString().ToLower() : attrValue);
}
public KerppiMain()
{
InitializeComponent();
Application.Current.DispatcherUnhandledException += KerppiExceptionHandler;
Title = AttributeHelper.GetAttribute <System.Reflection.AssemblyProductAttribute>().Product;
}
void RegisterFactories()
{
var types = AttributeHelper.GetInterfacesWithSpecificAttribute(AssemblyName, typeof(WindsorFactoryAttribute));
RegisterEachTypeAsFactory(types);
}
public string GetHtml(string url, out HttpStatusCode code,
string post = null)
{
string result = "";
HttpHelper.HttpResponse response;
code = HttpStatusCode.NotFound;
if (Regex.IsMatch(url, @"^[A-Z]:\\")) //本地文件
{
if (File.Exists(url))
{
result = File.ReadAllText(url, AttributeHelper.GetEncoding(this.Http.Encoding));
code = HttpStatusCode.Accepted;
}
}
else
{
var mc = extract.Matches(url);
if (SysProcessManager == null)
{
code = HttpStatusCode.NoContent;
return("");
}
var crawler = this.SysProcessManager.GetTask <SmartCrawler>(ShareCookie.SelectItem);
if (crawler != null)
{
Http.ProxyIP = crawler.Http.ProxyIP;
if (Http.Parameters != crawler.Http.Parameters)
{
var cookie = crawler.Http.GetHeaderParameter().Get <string>("Cookie");
if (string.IsNullOrWhiteSpace(cookie) == false)
{
Http.SetValue("Cookie", cookie);
}
}
}
Dictionary <string, string> paradict = null;
foreach (Match m in mc)
{
if (paradict == null)
{
paradict = XPathAnalyzer.ParseUrl(URL);
}
if (paradict == null)
{
break;
}
var str = m.Groups[1].Value;
if (paradict.ContainsKey(str))
{
url = url.Replace(m.Groups[0].Value, paradict[str]);
}
}
response = helper.GetHtml(Http, url, post).Result;
result = response.Html;
code = response.Code;
}
result = JavaScriptAnalyzer.Decode(result);
if (IsSuperMode)
{
result = JavaScriptAnalyzer.Parse2XML(result);
}
return(result);
}
private static void CreateMethod(CompilerClassLoader loader, TypeBuilder tb, ProxyMethod pm)
{
MethodBuilder mb = pm.mw.GetDefineMethodHelper().DefineMethod(loader.GetTypeWrapperFactory(), tb, pm.mw.Name, MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.Final);
List <string> exceptions = new List <string>();
foreach (TypeWrapper tw in pm.exceptions)
{
exceptions.Add(tw.Name);
}
AttributeHelper.SetThrowsAttribute(mb, exceptions.ToArray());
CodeEmitter ilgen = CodeEmitter.Create(mb);
ilgen.BeginExceptionBlock();
ilgen.Emit(OpCodes.Ldarg_0);
invocationHandlerField.EmitGet(ilgen);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldsfld, pm.fb);
TypeWrapper[] parameters = pm.mw.GetParameters();
if (parameters.Length == 0)
{
ilgen.Emit(OpCodes.Ldnull);
}
else
{
ilgen.EmitLdc_I4(parameters.Length);
ilgen.Emit(OpCodes.Newarr, Types.Object);
for (int i = 0; i < parameters.Length; i++)
{
ilgen.Emit(OpCodes.Dup);
ilgen.EmitLdc_I4(i);
ilgen.EmitLdarg(i);
if (parameters[i].IsNonPrimitiveValueType)
{
parameters[i].EmitBox(ilgen);
}
else if (parameters[i].IsPrimitive)
{
Boxer.EmitBox(ilgen, parameters[i]);
}
ilgen.Emit(OpCodes.Stelem_Ref);
}
}
invokeMethod.EmitCallvirt(ilgen);
TypeWrapper returnType = pm.mw.ReturnType;
CodeEmitterLocal returnValue = null;
if (returnType != PrimitiveTypeWrapper.VOID)
{
returnValue = ilgen.DeclareLocal(returnType.TypeAsSignatureType);
if (returnType.IsNonPrimitiveValueType)
{
returnType.EmitUnbox(ilgen);
}
else if (returnType.IsPrimitive)
{
Boxer.EmitUnbox(ilgen, returnType);
}
else if (returnType != CoreClasses.java.lang.Object.Wrapper)
{
ilgen.EmitCastclass(returnType.TypeAsSignatureType);
}
ilgen.Emit(OpCodes.Stloc, returnValue);
}
CodeEmitterLabel returnLabel = ilgen.DefineLabel();
ilgen.EmitLeave(returnLabel);
// TODO consider using a filter here (but we would need to add filter support to CodeEmitter)
ilgen.BeginCatchBlock(Types.Exception);
ilgen.EmitLdc_I4(0);
ilgen.Emit(OpCodes.Call, ByteCodeHelperMethods.mapException.MakeGenericMethod(Types.Exception));
CodeEmitterLocal exception = ilgen.DeclareLocal(Types.Exception);
ilgen.Emit(OpCodes.Stloc, exception);
CodeEmitterLabel rethrow = ilgen.DefineLabel();
ilgen.Emit(OpCodes.Ldloc, exception);
errorClass.EmitInstanceOf(null, ilgen);
ilgen.EmitBrtrue(rethrow);
ilgen.Emit(OpCodes.Ldloc, exception);
runtimeExceptionClass.EmitInstanceOf(null, ilgen);
ilgen.EmitBrtrue(rethrow);
foreach (TypeWrapper tw in pm.exceptions)
{
ilgen.Emit(OpCodes.Ldloc, exception);
tw.EmitInstanceOf(null, ilgen);
ilgen.EmitBrtrue(rethrow);
}
ilgen.Emit(OpCodes.Ldloc, exception);
undeclaredThrowableExceptionConstructor.EmitNewobj(ilgen);
ilgen.Emit(OpCodes.Throw);
ilgen.MarkLabel(rethrow);
ilgen.Emit(OpCodes.Rethrow);
ilgen.EndExceptionBlock();
ilgen.MarkLabel(returnLabel);
if (returnValue != null)
{
ilgen.Emit(OpCodes.Ldloc, returnValue);
}
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
}
public override void TraverseChildren(IMethodDefinition methodDefinition)
{
if (!this.printCompilerGeneratedMembers)
{
if (methodDefinition.IsConstructor && methodDefinition.ParameterCount == 0 &&
AttributeHelper.Contains(methodDefinition.Attributes, methodDefinition.Type.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute))
{
return;
}
// Skip if this is a method generated for use by a property or event
foreach (var p in methodDefinition.ContainingTypeDefinition.Properties)
{
if ((p.Getter != null && p.Getter.ResolvedMethod == methodDefinition) ||
(p.Setter != null && p.Setter.ResolvedMethod == methodDefinition))
{
return;
}
}
foreach (var e in methodDefinition.ContainingTypeDefinition.Events)
{
if ((e.Adder != null && e.Adder.ResolvedMethod == methodDefinition) ||
(e.Remover != null && e.Remover.ResolvedMethod == methodDefinition))
{
return;
}
}
if (AttributeHelper.Contains(methodDefinition.Attributes, methodDefinition.Type.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute))
{
return; // eg. an iterator helper - may have invalid identifier name
}
}
// Cctors should probably be outputted in some cases
if (methodDefinition.IsStaticConstructor)
{
return;
}
foreach (var ma in SortAttributes(methodDefinition.Attributes))
{
if (Utils.GetAttributeType(ma) != SpecialAttribute.Extension)
{
PrintAttribute(methodDefinition, ma, true, null);
}
}
foreach (var ra in SortAttributes(methodDefinition.ReturnValueAttributes))
{
PrintAttribute(methodDefinition, ra, true, "return");
}
PrintToken(CSharpToken.Indent);
PrintMethodDefinitionVisibility(methodDefinition);
PrintMethodDefinitionModifiers(methodDefinition);
bool conversion = IsConversionOperator(methodDefinition);
if (!conversion)
{
PrintMethodDefinitionReturnType(methodDefinition);
if (!methodDefinition.IsConstructor && !IsDestructor(methodDefinition))
{
PrintToken(CSharpToken.Space);
}
}
PrintMethodDefinitionName(methodDefinition);
if (conversion)
{
PrintMethodDefinitionReturnType(methodDefinition);
}
if (methodDefinition.IsGeneric)
{
Traverse(methodDefinition.GenericParameters);
}
Traverse(methodDefinition.Parameters);
if (methodDefinition.IsGeneric)
{
PrintConstraints(methodDefinition.GenericParameters);
}
if (!methodDefinition.IsAbstract && !methodDefinition.IsExternal)
{
Traverse(methodDefinition.Body);
}
else
{
PrintToken(CSharpToken.Semicolon);
}
}
/// <summary>
/// 分析一个类型中的所有智能属性
/// </summary>
/// <param name="type">要分析的类型</param>
/// <returns>返回分析的结果</returns>
public override Dictionary <short, GetObjectAnalyseResult> Analyse(Type type)
{
if (type == null)
{
return(null);
}
Dictionary <short, GetObjectAnalyseResult> result = GetObject(type.FullName);
if (result != null)
{
return(result);
}
var targetProperties = type.GetProperties().AsParallel().Where(property => AttributeHelper.GetCustomerAttribute <ThriftPropertyAttribute>(property) != null);
if (!targetProperties.Any())
{
return(null);
}
result = targetProperties.Select(property => new GetObjectAnalyseResult
{
VTStruct = GetVT(property.PropertyType),
Property = property,
TargetType = type,
Nullable = Nullable.GetUnderlyingType(property.PropertyType) != null,
Attribute = AttributeHelper.GetCustomerAttribute <ThriftPropertyAttribute>(property)
}.Initialize()).DefaultIfEmpty().OrderBy(property => property.Attribute.Id).ToDictionary(property => property.Attribute.Id);
RegistAnalyseResult(type.FullName, result);
return(result);
}
public EntitySet(EntityContext context)
{
this._helper = Xinchen.DbEntity.DbHelper.GetInstance(context.DbHelper.ConnectionString);
this._entityType = typeof(TEntity);
this._entityMapper = new EntityMapper <TEntity>();
this._properties = this._entityMapper.Properties;
this._propertyNames = new string[this._properties.Length];
this._propertyDict = new Dictionary <string, PropertyInfo>();
for (int i = 0; i < this._properties.Length; i++)
{
this._propertyNames[i] = "[" + this._properties[i].Name + "]";
this._propertyDict.Add(this._properties[i].Name, this._properties[i]);
}
this._tableAttr = (TableAttribute)this._entityType.GetCustomAttributes(EntitySet <TEntity> ._tableAttrType, true).FirstOrDefault <object>();
this._keyProperty = this._properties.FirstOrDefault <PropertyInfo>(propertyInfo => AttributeHelper.GetAttribute <KeyAttribute>(propertyInfo) != null);
if (this._keyProperty == null)
{
throw new EntityException("实体没有主键:" + TypeName);
}
this._autoIncrementProperty = this._properties.FirstOrDefault <PropertyInfo>(x => AttributeHelper.GetAttribute <AutoIncrementAttribute>(x) != null);
}
public static IEnumerable <CustomPropertyInfo> GetToolProperty(Type tool, Object instance = null, bool mustBrowsable = true)
{
Object newinstance;
if (instance == null)
{
instance = PluginProvider.GetObjectInstance(tool);
newinstance = instance;
}
else
{
newinstance = PluginProvider.GetObjectInstance(tool);
}
var propertys =
tool.GetProperties().Where(
d => d.CanRead && d.CanWrite && AttributeHelper.IsEditableType(d.PropertyType)).ToArray();
foreach (var propertyInfo in propertys.OrderBy(GetOrder))
{
var name = propertyInfo.Name;
if (name == "ObjectID" || name == "Enabled" || name == "ColumnSelector")
{
continue;
}
var property = new CustomPropertyInfo();
string typeName = null;
var defaultValue = GetDefaultValue(propertyInfo, newinstance, out typeName);
var currentValue = GetDefaultValue(propertyInfo, instance, out typeName);
property.CurrentValue = currentValue;
property.DefaultValue = defaultValue;
var desc = GlobalHelper.Get("no_desc");
// var fi =type.GetField(propertyInfo.Name);
var browseable =
(BrowsableAttribute[])propertyInfo.GetCustomAttributes(typeof(BrowsableAttribute), false);
if (browseable.Length > 0 && browseable[0].Browsable == false && mustBrowsable)
{
continue;
}
var descriptionAttributes =
(LocalizedDescriptionAttribute[])propertyInfo.GetCustomAttributes(
typeof(LocalizedDescriptionAttribute), false);
var nameAttributes =
(LocalizedDisplayNameAttribute[])propertyInfo.GetCustomAttributes(
typeof(LocalizedDisplayNameAttribute), false);
if (nameAttributes.Length > 0)
{
name = GlobalHelper.Get(nameAttributes[0].DisplayName);
}
if (descriptionAttributes.Length > 0)
{
desc = GlobalHelper.Get(descriptionAttributes[0].Description);
}
desc = string.Join("\n", desc.Split('\n').Select(d => d.Trim('\t', ' ')));
property.Desc = desc;
property.Name = name;
property.DefaultValue = defaultValue;
property.OriginName = propertyInfo.Name;
property.TypeName = typeName;
yield return(property);
}
}
protected View CreateHeader()
{
var type = GetListItemType();
if (type == null)
{
_header.BackgroundColor = headerBackgroundColor;
return(_header);
}
var attrib = type.GetAttribute <AutoFormsListUIAttribute>();
_header = new Grid
{
ColumnSpacing = attrib.ColumnSpacing,
RowSpacing = 0,
HorizontalOptions = LayoutOptions.FillAndExpand,
VerticalOptions = LayoutOptions.StartAndExpand,
RowDefinitions = new RowDefinitionCollection
{
new RowDefinition {
Height = GridLength.Auto
}
}
};
Grid.SetRow(_header, 1);
_header.Padding = new Thickness(attrib.ListItemPaddingLeft, attrib.ListHeaderPaddingTop, attrib.ListItemPaddingRight, attrib.ListHeaderPaddingBottom);
var headerStyle = attrib?.ColumnHeaderGridStyle ?? null;
if (string.IsNullOrEmpty(headerStyle) == false &&
Application.Current.Resources.TryGetValue(headerStyle, out object headerObj))
{
_header.Style = (Style)headerObj;
}
else
{
_header.BackgroundColor = headerBackgroundColor;
}
var props = AttributeHelper.GetPropertyAttributes <AutoFormsListItemAttribute>(type);
var style = LabelStyle;
Style sortButtonStyle = null;
var headerLabelStyle = attrib?.ColumnHeaderLabelStyle ?? null;
var headerSortButtonStyle = attrib?.ColumnHeaderSortButtonStyle ?? null;
if (string.IsNullOrEmpty(headerLabelStyle) == false &&
Application.Current.Resources.TryGetValue(headerLabelStyle, out object obj))
{
style = (Style)obj;
}
if (string.IsNullOrEmpty(headerSortButtonStyle) == false &&
Application.Current.Resources.TryGetValue(headerSortButtonStyle, out object sortButtonStyleObj))
{
sortButtonStyle = (Style)sortButtonStyleObj;
}
string sortedStateProperty = null;
if (_config.Attribute is AutoFormsListAttribute listAttribute)
{
sortedStateProperty = listAttribute.SortedStateProperty;
}
foreach (var p in props)
{
var property = p.Item1;
var attribute = GetFilteredAttribute(Filter, p.Item2);
if (property == null || attribute == null)
{
continue;
}
_header.ColumnDefinitions.Add(new ColumnDefinition {
Width = new GridLength(attribute.Value, attribute.GridType)
});
View view;
if (attribute.SortValue != null && !string.IsNullOrWhiteSpace(sortedStateProperty))
{
view = new SortButton
{
Text = attribute.Label,
VerticalOptions = LayoutOptions.CenterAndExpand,
HorizontalOptions = LayoutOptions.StartAndExpand,
SortValue = attribute.SortValue
};
if (sortButtonStyle != null)
{
view.Style = sortButtonStyle;
}
view.SetBinding(SortButton.SortedStateProperty, sortedStateProperty);
}
else
{
view = new Label
{
Style = style,
Text = attribute.Label,
VerticalOptions = LayoutOptions.CenterAndExpand,
VerticalTextAlignment = TextAlignment.Start,
HorizontalOptions = LayoutOptions.StartAndExpand,
HorizontalTextAlignment = attribute.HorizontalHeaderAlignment,
LineBreakMode = LineBreakMode.TailTruncation,
};
}
//view.BackgroundColor = Color.Green;
Grid.SetColumn(view, _header.ColumnDefinitions.Count - 1);
_header.Children.Add(view);
}
if (HasActions)
{
_header.ColumnDefinitions.Add(new ColumnDefinition {
Width = new GridLength(ActionButtonWidth, GridUnitType.Absolute)
});
}
_header.DebugGrid(Color.Transparent);
return(_header);
}
/// <summary>
/// Tries to get the assembly set up tear down attribute.
/// </summary>
/// <param name="assembly">The assembly.</param>
/// <param name="setUp">The set up.</param>
/// <param name="tearDown">The tear down.</param>
/// <returns>True if found.</returns>
public override bool TryGetAssemblySetupTeardownMethods(
AssemblyEx assembly,
out Method setUp,
out Method tearDown)
{
// <preconditions>
SafeDebug.AssumeNotNull((object)assembly, "assembly");
// </preconditions>
setUp = tearDown = null;
// look for [TestClass] types
foreach (var typeDefinition in assembly.TypeDefinitions)
{
if (typeDefinition.IsVisible(VisibilityContext.Exported))
{
if (typeDefinition.IsEnumType ||
typeDefinition.GenericTypeParameters.Length > 0)
{
continue;
}
if (!this.IsFixture(typeDefinition))
{
continue;
}
// looking for assembly setup/teardown methods
foreach (var methodDefinition in typeDefinition.DeclaredStaticMethods)
{
if (methodDefinition.IsVisible(VisibilityContext.Exported) &&
methodDefinition.GenericMethodParameters.Length == 0)
{
if (AttributeHelper.IsDefined(methodDefinition, this.AssemblySetUpAttribute, true))
{
setUp = methodDefinition.Instantiate(TypeEx.NoTypes, TypeEx.NoTypes);
}
if (AttributeHelper.IsDefined(methodDefinition, this.AssemblyTearDownAttribute, true))
{
tearDown = methodDefinition.Instantiate(TypeEx.NoTypes, TypeEx.NoTypes);
}
// nothing else to look for
if (setUp != null && tearDown != null)
{
break;
}
}
}
// nothing else to look for
if (setUp != null && tearDown != null)
{
break;
}
}
}
return(setUp != null || tearDown != null);
}
public override void ApplyAttribute(ulong attributeEventHandlerId, string attributeName, object attributeValue, string attributeEventUpdatesAttributeName)
{
switch (attributeName)
{
case nameof(XFD.TwoPaneView.MinTallModeHeight):
TwoPaneViewControl.MinTallModeHeight = AttributeHelper.StringToDouble((string)attributeValue);
break;
case nameof(XFD.TwoPaneView.MinWideModeWidth):
TwoPaneViewControl.MinWideModeWidth = AttributeHelper.StringToDouble((string)attributeValue);
break;
case nameof(XFD.TwoPaneView.Pane1Length):
TwoPaneViewControl.Pane1Length = AttributeHelper.StringToGridLength(attributeValue, XF.GridLength.Star);
break;
case nameof(XFD.TwoPaneView.Pane2Length):
TwoPaneViewControl.Pane2Length = AttributeHelper.StringToGridLength(attributeValue, XF.GridLength.Star);
break;
case nameof(XFD.TwoPaneView.PanePriority):
TwoPaneViewControl.PanePriority = (XFD.TwoPaneViewPriority)AttributeHelper.GetInt(attributeValue);
break;
case nameof(XFD.TwoPaneView.TallModeConfiguration):
TwoPaneViewControl.TallModeConfiguration = (XFD.TwoPaneViewTallModeConfiguration)AttributeHelper.GetInt(attributeValue, (int)XFD.TwoPaneViewTallModeConfiguration.TopBottom);
break;
case nameof(XFD.TwoPaneView.WideModeConfiguration):
TwoPaneViewControl.WideModeConfiguration = (XFD.TwoPaneViewWideModeConfiguration)AttributeHelper.GetInt(attributeValue, (int)XFD.TwoPaneViewWideModeConfiguration.LeftRight);
break;
default:
base.ApplyAttribute(attributeEventHandlerId, attributeName, attributeValue, attributeEventUpdatesAttributeName);
break;
}
}
private SceneInfoAttribute CollectSceneInfo(MemberInfo mi)
{
return(AttributeHelper.GetCustomAttribute <SceneInfoAttribute>(mi));
}
internal static void WriteClass(Stream stream, TypeWrapper tw, bool includeNonPublicInterfaces, bool includeNonPublicMembers, bool includeSerialVersionUID)
{
string name = tw.Name.Replace('.', '/');
string super = null;
if (tw.IsInterface)
{
super = "java/lang/Object";
}
else if (tw.BaseTypeWrapper != null)
{
super = tw.BaseTypeWrapper.Name.Replace('.', '/');
}
ClassFileWriter writer = new ClassFileWriter(tw.Modifiers, name, super, 0, 49);
foreach (TypeWrapper iface in tw.Interfaces)
{
if (iface.IsPublic || includeNonPublicInterfaces)
{
writer.AddInterface(iface.Name.Replace('.', '/'));
}
}
InnerClassesAttribute innerClassesAttribute = null;
if (tw.DeclaringTypeWrapper != null)
{
TypeWrapper outer = tw.DeclaringTypeWrapper;
string innername = name;
int idx = name.LastIndexOf('$');
if (idx >= 0)
{
innername = innername.Substring(idx + 1);
}
innerClassesAttribute = new InnerClassesAttribute(writer);
innerClassesAttribute.Add(name, outer.Name.Replace('.', '/'), innername, (ushort)tw.ReflectiveModifiers);
}
foreach (TypeWrapper inner in tw.InnerClasses)
{
if (inner.IsPublic)
{
if (innerClassesAttribute == null)
{
innerClassesAttribute = new InnerClassesAttribute(writer);
}
string namePart = inner.Name;
namePart = namePart.Substring(namePart.LastIndexOf('$') + 1);
innerClassesAttribute.Add(inner.Name.Replace('.', '/'), name, namePart, (ushort)inner.ReflectiveModifiers);
}
}
if (innerClassesAttribute != null)
{
writer.AddAttribute(innerClassesAttribute);
}
string genericTypeSignature = tw.GetGenericSignature();
if (genericTypeSignature != null)
{
writer.AddStringAttribute("Signature", genericTypeSignature);
}
AddAnnotations(writer, writer, tw.TypeAsBaseType);
writer.AddStringAttribute("IKVM.NET.Assembly", GetAssemblyName(tw));
if (tw.TypeAsBaseType.IsDefined(JVM.Import(typeof(ObsoleteAttribute)), false))
{
writer.AddAttribute(new DeprecatedAttribute(writer));
}
foreach (MethodWrapper mw in tw.GetMethods())
{
if (!mw.IsHideFromReflection && (mw.IsPublic || mw.IsProtected || includeNonPublicMembers))
{
FieldOrMethod m;
if (mw.Name == "<init>")
{
m = writer.AddMethod(mw.Modifiers, mw.Name, mw.Signature.Replace('.', '/'));
CodeAttribute code = new CodeAttribute(writer);
code.MaxLocals = (ushort)(mw.GetParameters().Length * 2 + 1);
code.MaxStack = 3;
ushort index1 = writer.AddClass("java/lang/UnsatisfiedLinkError");
ushort index2 = writer.AddString("ikvmstub generated stubs can only be used on IKVM.NET");
ushort index3 = writer.AddMethodRef("java/lang/UnsatisfiedLinkError", "<init>", "(Ljava/lang/String;)V");
code.ByteCode = new byte[] {
187, (byte)(index1 >> 8), (byte)index1, // new java/lang/UnsatisfiedLinkError
89, // dup
19, (byte)(index2 >> 8), (byte)index2, // ldc_w "..."
183, (byte)(index3 >> 8), (byte)index3, // invokespecial java/lang/UnsatisfiedLinkError/init()V
191 // athrow
};
m.AddAttribute(code);
}
else
{
Modifiers mods = mw.Modifiers;
if ((mods & Modifiers.Abstract) == 0)
{
mods |= Modifiers.Native;
}
m = writer.AddMethod(mods, mw.Name, mw.Signature.Replace('.', '/'));
if (mw.IsOptionalAttributeAnnotationValue)
{
m.AddAttribute(new AnnotationDefaultClassFileAttribute(writer, GetAnnotationDefault(writer, mw.ReturnType)));
}
}
MethodBase mb = mw.GetMethod();
if (mb != null)
{
ThrowsAttribute throws = AttributeHelper.GetThrows(mb);
if (throws == null)
{
string[] throwsArray = mw.GetDeclaredExceptions();
if (throwsArray != null && throwsArray.Length > 0)
{
ExceptionsAttribute attrib = new ExceptionsAttribute(writer);
foreach (string ex in throwsArray)
{
attrib.Add(ex.Replace('.', '/'));
}
m.AddAttribute(attrib);
}
}
else
{
ExceptionsAttribute attrib = new ExceptionsAttribute(writer);
if (throws.classes != null)
{
foreach (string ex in throws.classes)
{
attrib.Add(ex.Replace('.', '/'));
}
}
if (throws.types != null)
{
foreach (Type ex in throws.types)
{
attrib.Add(ClassLoaderWrapper.GetWrapperFromType(ex).Name.Replace('.', '/'));
}
}
m.AddAttribute(attrib);
}
if (mb.IsDefined(JVM.Import(typeof(ObsoleteAttribute)), false)
// HACK the instancehelper methods are marked as Obsolete (to direct people toward the ikvm.extensions methods instead)
// but in the Java world most of them are not deprecated (and to keep the Japi results clean we need to reflect this)
&& (!mb.Name.StartsWith("instancehelper_") ||
mb.DeclaringType.FullName != "java.lang.String"
// the Java deprecated methods actually have two Obsolete attributes
|| GetObsoleteCount(mb) == 2))
{
m.AddAttribute(new DeprecatedAttribute(writer));
}
CustomAttributeData attr = GetAnnotationDefault(mb);
if (attr != null)
{
m.AddAttribute(new AnnotationDefaultClassFileAttribute(writer, GetAnnotationDefault(writer, attr.ConstructorArguments[0])));
}
}
string sig = tw.GetGenericMethodSignature(mw);
if (sig != null)
{
m.AddAttribute(writer.MakeStringAttribute("Signature", sig));
}
AddAnnotations(writer, m, mw.GetMethod());
AddParameterAnnotations(writer, m, mw.GetMethod());
}
}
bool hasSerialVersionUID = false;
foreach (FieldWrapper fw in tw.GetFields())
{
if (!fw.IsHideFromReflection)
{
bool isSerialVersionUID = includeSerialVersionUID && fw.Name == "serialVersionUID" && fw.FieldTypeWrapper == PrimitiveTypeWrapper.LONG;
hasSerialVersionUID |= isSerialVersionUID;
if (fw.IsPublic || fw.IsProtected || isSerialVersionUID || includeNonPublicMembers)
{
object constant = null;
if (fw.GetField() != null && fw.GetField().IsLiteral&& (fw.FieldTypeWrapper.IsPrimitive || fw.FieldTypeWrapper == CoreClasses.java.lang.String.Wrapper))
{
constant = fw.GetField().GetRawConstantValue();
if (fw.GetField().FieldType.IsEnum)
{
constant = EnumHelper.GetPrimitiveValue(EnumHelper.GetUnderlyingType(fw.GetField().FieldType), constant);
}
}
FieldOrMethod f = writer.AddField(fw.Modifiers, fw.Name, fw.Signature.Replace('.', '/'), constant);
string sig = tw.GetGenericFieldSignature(fw);
if (sig != null)
{
f.AddAttribute(writer.MakeStringAttribute("Signature", sig));
}
if (fw.GetField() != null && fw.GetField().IsDefined(JVM.Import(typeof(ObsoleteAttribute)), false))
{
f.AddAttribute(new DeprecatedAttribute(writer));
}
AddAnnotations(writer, f, fw.GetField());
}
}
}
if (includeSerialVersionUID && !hasSerialVersionUID && IsSerializable(tw))
{
// class is serializable but doesn't have an explicit serialVersionUID, so we add the field to record
// the serialVersionUID as we see it (mainly to make the Japi reports more realistic)
writer.AddField(Modifiers.Private | Modifiers.Static | Modifiers.Final, "serialVersionUID", "J", SerialVersionUID.Compute(tw));
}
AddMetaAnnotations(writer, tw);
writer.Write(stream);
}
protected string GetCollectionName()
{
return(AttributeHelper.GetBsonCollectionAttributeName(typeof(T)));
}
/// <summary>
/// Регистрируем тип сообщения
/// </summary>
/// <param name="provider"></param>
/// <param name="type"></param>
/// <returns></returns>
public static IMessageTypeProvider Register(this IMessageTypeProvider provider, Type type)
{
var tag = AttributeHelper.GetPropertyName <MessageQueueNameAttribute>(type, true);
return(provider.Register(tag, type));
}
public static ProductFieldStatus Status(this ProductFields enumValue)
{
var attrValue = AttributeHelper.GetAttributeValue <ProductFieldsStatusAttribute, ProductFieldStatus>(enumValue);
return(attrValue);
}
public void HandleDeliveryReportTimeout()
{
UniqueJob uniqueJob = this.uniqueJobList.AddOrUpdate("HandleDeliveryReportTimeout");
if (uniqueJob == null)
{
return; // Job 已經存在
}
try
{
using (var scope = this.unitOfWork.CreateTransactionScope())
{
// 若一天之後，SendMessageHistory 狀態仍然為 MessageAccepted (仍未取得派送結果)，
// 則將此筆 SendMessageHistory 狀態改成 DeliveryReportTimeout
var sendMessageRuleRepository = this.unitOfWork.Repository <SendMessageRule>();
var sendMessageQueueRepository = this.unitOfWork.Repository <SendMessageQueue>();
var sendMessageHistoryRepository = this.unitOfWork.Repository <SendMessageHistory>();
var expiryDate = DateTime.UtcNow.AddTicks(-1 * DeliveryReportQueue.QueryInterval.Ticks);
var entities = sendMessageHistoryRepository
.GetMany(p =>
(p.DeliveryStatus == DeliveryReportStatus.MessageAccepted || // Infobip
p.DeliveryStatus == DeliveryReportStatus.Sending) && // Every8d
// 已經過期
p.CreatedTime < expiryDate)
.ToList();
var sendMessageQueueIds = entities.Select(p => p.SendMessageQueueId).Distinct().ToList();
var sendMessageRuleIds = entities.Select(p => p.SendMessageRuleId).Distinct().ToList();
var sendMessageQueues = sendMessageQueueRepository.GetMany(p => sendMessageQueueIds.Contains(p.Id)).ToList();
var sendMessageRules = sendMessageRuleRepository.GetMany(p => sendMessageRuleIds.Contains(p.Id)).ToList();
foreach (var entity in entities)
{
var oldDeliveryStatus = entity.DeliveryStatus;
var newDeliveryStatus = DeliveryReportStatus.DeliveryReportTimeout;
var sendMessageQueue = sendMessageQueues.Find(p => p.Id == entity.SendMessageQueueId);
var sendMessageRule = sendMessageRules.Find(p => p.Id == entity.SendMessageRuleId);
this.logService.Debug("{0}(簡訊編號：{1}，序列編號:{2})，收訊門號{3}已超過{4}未經收到派送結果，接收狀態將由{5}改成{6}",
AttributeHelper.GetColumnDescription(sendMessageRule.SendTimeType),
sendMessageRule.Id,
sendMessageQueue.Id,
entity.DestinationAddress,
DeliveryReportQueue.QueryInterval.ToString(),
oldDeliveryStatus.ToString(),
newDeliveryStatus.ToString());
entity.DeliveryStatus = newDeliveryStatus;
entity.DeliveryStatusString = entity.DeliveryStatus.ToString();
entity.Delivered = false;
sendMessageHistoryRepository.Update(entity);
// 如果發送失敗，就回補點數
// 20151123 Norman, Eric 要求發送失敗不回補點數
//tradeService.HandleSendMessageHistory(sendMessageRule, sendMessageQueue, entity);
}
foreach (var sendMessageQueueId in sendMessageQueueIds)
{
this.logService.Debug("簡訊序列編號:{0})，重新計算 SendMessageStatistic", sendMessageQueueId);
this.sendMessageStatisticService.AddOrUpdateSendMessageStatistic(sendMessageQueueId);
}
scope.Complete();
}
}
catch (Exception ex)
{
this.logService.Error(ex);
throw;
}
finally
{
this.uniqueJobList.Remove(uniqueJob);
}
}
public void Controller_ShouldNotHaveAnonymousActions()
{
AttributeHelper.ShouldNotHaveAnonymousMethods(typeof(UnauthenticatedUserController));
}
public virtual PropertyViewModel CreateViewModel(object instance, PropertyDescriptor descriptor)
{
PropertyViewModel propertyViewModel = null;
// Optional by Nullable type
var nullable = descriptor.PropertyType.IsGenericType &&
descriptor.PropertyType.GetGenericTypeDefinition() == typeof(Nullable <>);
if (nullable)
{
propertyViewModel = new OptionalPropertyViewModel(instance, descriptor, null, owner);
}
// Optional by Attribute
var oa = AttributeHelper.GetAttribute <OptionalAttribute>(descriptor);
if (oa != null)
{
propertyViewModel = new OptionalPropertyViewModel(instance, descriptor, oa.PropertyName, owner);
}
// Wide
var wa = AttributeHelper.GetAttribute <WidePropertyAttribute>(descriptor);
if (wa != null)
{
propertyViewModel = new WidePropertyViewModel(instance, descriptor, wa.ShowHeader, owner);
}
// If bool properties should be shown as checkbox only (no header label), we create
// a CheckBoxPropertyViewModel
if (descriptor.PropertyType == typeof(bool) && owner != null && !owner.ShowBoolHeader)
{
propertyViewModel = new CheckBoxPropertyViewModel(instance, descriptor, owner);
}
// Properties with the Slidable attribute set
var sa = AttributeHelper.GetAttribute <SlidableAttribute>(descriptor);
if (sa != null)
{
propertyViewModel = new SlidablePropertyViewModel(instance, descriptor, owner)
{
SliderMinimum = sa.Minimum,
SliderMaximum = sa.Maximum,
SliderLargeChange = sa.LargeChange,
SliderSmallChange = sa.SmallChange
}
}
;
// FilePath
var fpa = AttributeHelper.GetAttribute <FilePathAttribute>(descriptor);
if (fpa != null)
{
propertyViewModel = new FilePathPropertyViewModel(instance, descriptor, owner)
{
Filter = fpa.Filter, DefaultExtension = fpa.DefaultExtension
}
}
;
// DirectoryPath
var dpa = AttributeHelper.GetAttribute <DirectoryPathAttribute>(descriptor);
if (dpa != null)
{
propertyViewModel = new DirectoryPathPropertyViewModel(instance, descriptor, owner);
}
// Default text property
if (propertyViewModel == null)
{
var tp = new PropertyViewModel(instance, descriptor, owner);
propertyViewModel = tp;
}
var fsa = AttributeHelper.GetAttribute <FormatStringAttribute>(descriptor);
if (fsa != null)
{
propertyViewModel.FormatString = fsa.FormatString;
}
var ha = AttributeHelper.GetAttribute <HeightAttribute>(descriptor);
if (ha != null)
{
propertyViewModel.Height = ha.Height;
}
if (propertyViewModel.Height > 0)
{
propertyViewModel.AcceptsReturn = true;
propertyViewModel.TextWrapping = TextWrapping.Wrap;
}
var soa = AttributeHelper.GetAttribute <SortOrderAttribute>(descriptor);
if (soa != null)
{
propertyViewModel.SortOrder = soa.SortOrder;
}
return(propertyViewModel);
}
}
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
if (!ContextDataCache.TryGetContextData <GUIStyle>("BigLabel", out var bigLabel))
{
bigLabel.value = new GUIStyle(GUI.skin.label);
bigLabel.value.fontSize = 18;
bigLabel.value.fontStyle = FontStyle.Bold;
bigLabel.value.alignment = TextAnchor.MiddleLeft;
bigLabel.value.stretchWidth = true;
}
ConfigAssetGroup groupAsset = target as ConfigAssetGroup;
GUILayoutExtension.VerticalGroup(() =>
{
GUILayout.Label($"Config:{groupAsset.name}", bigLabel.value);
});
GUILayoutExtension.VerticalGroup(() =>
{
List <Type> cnfTypes = new List <Type>();
List <string> cnfNames = new List <string>();
foreach (var item in ReflectionHelper.GetChildTypes <IConfig>())
{
string displayName = item.Name;
if (AttributeHelper.TryGetTypeAttribute(item, out ConfigAttribute attr))
{
displayName = attr.DisplayName;
}
cnfNames.Add(displayName);
cnfTypes.Add(item);
}
if (groupAsset.configTypeFullName == null)
{
EditorGUILayout.HelpBox("没有选择配置类！！！", MessageType.Error);
MiscHelper.Dropdown($"选择的配置类", cnfNames, (int a) => {
groupAsset.configTypeFullName = cnfTypes[a].FullName;
groupAsset.configTypeName = cnfTypes[a].Name;
}, 300);
}
else
{
MiscHelper.Dropdown(groupAsset.configTypeFullName, cnfNames, (int a) => {
groupAsset.configTypeFullName = cnfTypes[a].FullName;
groupAsset.configTypeName = cnfTypes[a].Name;
}, 300);
}
});
GUILayoutExtension.VerticalGroup(() => {
List <ConfigAsset> assets = groupAsset.GetAllAsset();
for (int i = 0; i < assets.Count; i++)
{
DrawGraph(groupAsset, assets[i]);
}
});
GUILayoutExtension.VerticalGroup(() =>
{
if (GUILayout.Button($"创建配置", GUILayout.Height(50)))
{
MiscHelper.Input($"输入配置名：", (string name) =>
{
groupAsset.CreateAsset(name);
});
}
});
}
public VhdFooterSerializer(VhdFooter vhdFooter)
{
this.vhdFooter = vhdFooter;
this.attributeHelper = new AttributeHelper <VhdFooter>();
}
public override BaseResponse GenerateResponse()
{
GetGameObjectResponse getGOResponse = new GetGameObjectResponse();
Transform foundTransform = TransformHelper.GetFromPath(gameObjectPath);
getGOResponse.GameObjectName = foundTransform.name;
List <Object> components = new List <Object>(foundTransform.GetComponents <Component>());
// Not technically a component, but include the GameObject
components.Insert(0, foundTransform.gameObject);
getGOResponse.Components = new List <ComponentDescription>(components.Count);
foreach (Object component in components)
{
//Guid guid = ObjectMap.AddOrGetObject(component);
ObjectMap.AddOrGetObject(component);
ComponentDescription description = new ComponentDescription(component);
Type componentType = component.GetType();
while (componentType != null &&
componentType != typeof(System.Object) &&
componentType != typeof(UnityEngine.Object) &&
componentType != typeof(UnityEngine.Component))
{
ComponentScope componentScope = new ComponentScope(componentType);
if ((flags & InfoFlags.Fields) == InfoFlags.Fields)
{
FieldInfo[] fieldInfos = componentType.GetFields(BINDING_FLAGS);
foreach (FieldInfo fieldInfo in fieldInfos)
{
if (TypeUtility.IsBackingField(fieldInfo, componentType))
{
// Skip backing fields for auto-implemented properties
continue;
}
object objectValue = fieldInfo.GetValue(component);
WrappedVariable wrappedVariable = new WrappedVariable(fieldInfo, objectValue);
componentScope.Fields.Add(wrappedVariable);
}
}
if (componentType == typeof(GameObject)) // Special handling for GameObject.name to always be included
{
PropertyInfo nameProperty = componentType.GetProperty("name", BindingFlags.Public | BindingFlags.Instance);
WrappedVariable wrappedName = new WrappedVariable(nameProperty, nameProperty.GetValue(component, null));
componentScope.Properties.Add(wrappedName);
}
if ((flags & InfoFlags.Properties) == InfoFlags.Properties)
{
PropertyInfo[] properties = componentType.GetProperties(BINDING_FLAGS);
foreach (PropertyInfo property in properties)
{
Type declaringType = property.DeclaringType;
if (declaringType == typeof(Component) ||
declaringType == typeof(UnityEngine.Object))
{
continue;
}
object[] attributes = property.GetCustomAttributes(false);
bool isObsoleteWithError = AttributeHelper.IsObsoleteWithError(attributes);
if (isObsoleteWithError)
{
continue;
}
// Skip properties that cause exceptions at edit time
if (Application.isPlaying == false)
{
if (typeof(MeshFilter).IsAssignableFrom(declaringType))
{
if (property.Name == "mesh")
{
continue;
}
}
if (typeof(Renderer).IsAssignableFrom(declaringType))
{
if (property.Name == "material" || property.Name == "materials")
{
continue;
}
}
}
string propertyName = property.Name;
MethodInfo getMethod = property.GetGetMethod(true);
if (getMethod != null)
{
//MethodImplAttributes methodImplAttributes = getMethod.GetMethodImplementationFlags();
//if ((methodImplAttributes & MethodImplAttributes.InternalCall) != 0)
//{
// continue;
//}
object objectValue = getMethod.Invoke(component, null);
WrappedVariable wrappedVariable = new WrappedVariable(property, objectValue);
componentScope.Properties.Add(wrappedVariable);
}
}
}
if ((flags & InfoFlags.Methods) == InfoFlags.Methods)
{
MethodInfo[] methodInfos = componentType.GetMethods(BINDING_FLAGS);
foreach (var methodInfo in methodInfos)
{
if (TypeUtility.IsPropertyMethod(methodInfo, componentType))
{
// Skip automatically generated getter/setter methods
continue;
}
MethodImplAttributes methodImplAttributes = methodInfo.GetMethodImplementationFlags();
if ((methodImplAttributes & MethodImplAttributes.InternalCall) != 0 && methodInfo.Name.StartsWith("INTERNAL_"))
{
// Skip any internal method if it also begins with INTERNAL_
continue;
}
WrappedMethod wrappedMethod = new WrappedMethod(methodInfo);
componentScope.Methods.Add(wrappedMethod);
}
}
description.Scopes.Add(componentScope);
componentType = componentType.BaseType;
}
getGOResponse.Components.Add(description);
}
return(getGOResponse);
}
protected override void RenderAttributes(AttributesBuilder builder)
{
base.RenderAttributes(builder);
if (BackgroundGradientAngle != null)
{
builder.AddAttribute(nameof(BackgroundGradientAngle), BackgroundGradientAngle.Value);
}
if (BackgroundGradientEndColor != null)
{
builder.AddAttribute(nameof(BackgroundGradientEndColor), AttributeHelper.ColorToString(BackgroundGradientEndColor.Value));
}
if (BackgroundGradientStartColor != null)
{
builder.AddAttribute(nameof(BackgroundGradientStartColor), AttributeHelper.ColorToString(BackgroundGradientStartColor.Value));
}
//IEnumerable<GradientStop> BackgroundGradientStops
if (BorderColor != null)
{
builder.AddAttribute(nameof(BorderColor), AttributeHelper.ColorToString(BorderColor.Value));
}
if (BorderDrawingStyle != null)
{
builder.AddAttribute(nameof(BorderDrawingStyle), (int)BorderDrawingStyle.Value);
}
if (BorderGradientAngle != null)
{
builder.AddAttribute(nameof(BorderGradientAngle), BorderGradientAngle.Value);
}
if (BorderGradientEndColor != null)
{
builder.AddAttribute(nameof(BorderGradientEndColor), AttributeHelper.ColorToString(BorderGradientEndColor.Value));
}
if (BorderGradientStartColor != null)
{
builder.AddAttribute(nameof(BorderGradientStartColor), AttributeHelper.ColorToString(BorderGradientStartColor.Value));
}
//IEnumerable<GradientStop> BorderGradientStops
if (BorderIsDashed != null)
{
builder.AddAttribute(nameof(BorderIsDashed), BorderIsDashed.Value);
}
if (BorderThickness != null)
{
builder.AddAttribute(nameof(BorderThickness), AttributeHelper.SingleToString(BorderThickness.Value));
}
if (CornerRadius != null)
{
builder.AddAttribute(nameof(CornerRadius), AttributeHelper.CornerRadiusToString(CornerRadius.Value));
}
if (Elevation != null)
{
builder.AddAttribute(nameof(Elevation), Elevation.Value);
}
if (HasShadow != null)
{
builder.AddAttribute(nameof(HasShadow), HasShadow.Value);
}
if (OffsetAngle != null)
{
builder.AddAttribute(nameof(OffsetAngle), AttributeHelper.DoubleToString(OffsetAngle.Value));
}
if (Sides != null)
{
builder.AddAttribute(nameof(Sides), Sides.Value);
}
}
public VhdFooterSerializer(VhdFooter vhdFooter)
{
this.vhdFooter = vhdFooter;
this.attributeHelper = new AttributeHelper<VhdFooter>();
}
// Does NOT include methods marked with SecuritySafeCriticalAttribute.
private bool IsSecurityCritical(ITypeDefinitionMember member)
{
return(AttributeHelper.Contains(member.Attributes, this.asmMetaHostEnvironment.platformType.SystemSecuritySecurityCriticalAttribute));
}
private static void ApplyChanges(List <SimpleUser> changes, ADToPermissionCenterSynchronizer context)
{
string[] changesIdArray = changes.Select <SimpleUser, string>(m => m.SCObjectID).ToArray();
PC.SchemaObjectCollection pcObjects = LoadSCObjects(changesIdArray);
foreach (SimpleUser item in changes)
{
if (pcObjects.ContainsKey(item.SCObjectID))
{
try
{
PC.SchemaObjectBase scObj = MeargeChanges(item.Tag, pcObjects[item.SCObjectID]);
PC.Adapters.SchemaObjectAdapter.Instance.Update(scObj);
context.Log.NumberOfModifiedItems++;
}
catch (Exception ex)
{
context.Log.NumberOfExceptions++;
context.Log.Status = ADSynchronizeResult.HasError;
LogHelper.WriteReverseSynchronizeDBLogDetail(context.Log.LogID, item.SCObjectID, AttributeHelper.Hex((byte[])item.Tag.Properties["objectguid"][0]), item.CodeName, ex.Message, ex.ToString());
Trace.TraceError("未成功更新," + ex.ToString());
}
}
else
{
LogHelper.WriteReverseSynchronizeDBLogDetail(context.Log.LogID, item.SCObjectID, AttributeHelper.Hex((byte[])item.Tag.Properties["objectguid"][0]), item.CodeName, "未找到AD对象对应的权限中心对象。", null);
}
}
}
public void SetupMetadata(CST.Global global)
{
NumWarnings = 0;
NumErrors = 0;
Global = global;
if (tracerStream != null)
Tracer = new CST.CSTWriter(global, CST.WriterStyle.Debug, tracerStream);
Validity = new ValidityContext(this);
GenericEnumeratorTypeConstructorRef = MkRef(Constants.GenericEnumeratorTypeConstructorName);
JSContextRef = MkRef(Constants.JSContextName);
JSObjectRef = MkRef(Constants.JSObjectName);
JSPropertyRef = MkRef(Constants.JSPropertyName);
JSExceptionRef = MkRef(Constants.JSExceptionName);
GlobalMapping = new GlobalMapping(this);
AttributeHelper = new AttributeHelper(this);
InteropManager = new InteropManager(this);
JSTHelpers = new JSTHelpers(this);
InlinedMethods = new InlinedMethodCache(this);
Traces = new Traces(this);
}
