public DependencyContainer Register(string name, Type type, Func <object> builder)
{
var cacheKey = new NameAndType(name, type);
if (!_registrations.TryGetValue(cacheKey, out var list))
{
_registrations.TryAdd(cacheKey, list = new List <Func <object> >());
}
list.Add(builder);
var enumerableCacheKey = new NameAndType($"{Constants.EnumerableSlot}{name}", typeof(IEnumerable <>).MakeGenericType(type));
if (_registrations.TryGetValue(enumerableCacheKey, out var enumerableList))
{
return(this);
}
if (_registrations.TryAdd(enumerableCacheKey, enumerableList = new List <Func <object> >()))
{
enumerableList.Add(() =>
{
var collection = (IList)Instancing.CreateInstance(typeof(List <>).MakeGenericType(type));
foreach (var itemBuilder in list)
{
collection.Add(itemBuilder());
}
return(collection);
});
}
return(this);
}
private static void CompareNewWay(NameAndType expectedField, PropertyInfo propertyInfo)
{
var foundAttributes = CustomAttributeData.GetCustomAttributes(propertyInfo)
.AsQueryable().OrderBy(a => a.ToString()).ToList();
Assert.AreEqual(expectedField.ParameterAttributes.Count, foundAttributes.Count(), "For Field: " + propertyInfo.Name);
if (foundAttributes.Count() > 0)
{
for (int j = 0; j < foundAttributes.Count(); j++)
{
//Assert.AreEqual(expectedField.Attributes[j], foundAttributes[j].ToString(), "For Field: " + propertyInfo.Name);
Assert.IsTrue(
foundAttributes[j].ToString().StartsWith(
expectedField.ParameterAttributes[j].AttributeNameStartsWith));
var namedParameters = foundAttributes[j].NamedArguments.ToList();
Assert.AreEqual(expectedField.ParameterAttributes[j].NamedParameters.Count, namedParameters.Count,
"For Field: " + propertyInfo.Name + " For Attribute: " + foundAttributes[j]);
if (namedParameters.Count > 0)
{
var namedParametersAsStrings = new List<string>();
foreach (var namedParameter in namedParameters)
{
namedParametersAsStrings.Add(namedParameter.ToString());
}
foreach (var expectedParameter in expectedField.ParameterAttributes[j].NamedParameters)
{
Assert.IsTrue(namedParametersAsStrings.Contains(expectedParameter), "For Field: " + propertyInfo.Name + " For Attribute: " + foundAttributes[j] + "Expected Parameter: " + expectedParameter + " Found: " + namedParametersAsStrings.ParseList());
}
}
}
}
}
protected override void ResolveInternal(ConstantPoolItemBase[] constantPool)
{
base.ResolveInternal(constantPool);
NameAndType.Resolve(constantPool);
this.Signature = JVMdotNET.Core.ClassFile.Signature.Signature.ParseFieldSignature(NameAndType.Descriptor);
}
public static MethodAnalysis Analyze(this CimMethodDeclaration d, IDictionary <string, CimTypeDeclaration> typeRepo)
{
TypeSyntax returnType;
var dotnetReturnType = CimConverter.GetDotNetType(d.ReturnType);
if (d.ReturnType == CimType.DateTime)
{
dotnetReturnType = typeof(DateTime);
}
if (d.ReturnType == CimType.DateTimeArray)
{
dotnetReturnType = typeof(DateTime[]);
}
if (dotnetReturnType == null)
{
returnType = SyntaxFactory.ParseTypeName("void");
}
else
{
returnType = SyntaxFactory.ParseTypeName(dotnetReturnType.FullName);
}
var inputParameters = new List <NameAndType>();
var outputParameters = new List <NameAndType>();
foreach (var p in d.Parameters)
{
var type = ResolveType(p.CimType, p.ReferenceClassName ?? p.Qualifiers["EmbeddedInstance"]?.Value as string, p.Qualifiers.IsNotNull(), typeRepo, out var isCimObject, out var isNullableValueType, out var isEnumerable, out var enumeratedType);
var entry = new NameAndType
{
IsCimObject = isCimObject,
Name = p.Name,
Type = type,
IsNullableValueType = isNullableValueType,
IsEnumerable = isEnumerable,
CimType = p.CimType,
EnumeratedType = enumeratedType,
};
if (IsIn(p))
{
inputParameters.Add(entry);
}
if (IsOut(p))
{
outputParameters.Add(entry);
}
}
return(new MethodAnalysis
{
ReturnType = returnType,
InputParameters = inputParameters.ToArray(),
OutputParameters = outputParameters.ToArray()
});
}
private void listView1_SelectedIndexChanged(object sender, EventArgs e)
{
if (listView1.SelectedItems.Count > 0)
{
NameAndType select = new NameAndType();
int lvi = listView1.SelectedItems[0].Index;
select = (NameAndType)data[lvi];
object dBdata = DBHelper.openByTypeAndName((select).name, (select).type);
m_mapControl.Map.ClearLayers();
//显示矢量图的方法
if ((select).type.StartsWith("f"))
{
IFeatureDataset queryData = (IFeatureDataset)dBdata;
IFeatureClassContainer datasetContainer = (IFeatureClassContainer)queryData;
IFeatureLayer m_FeatureLayer;
for (int i = 0; i < datasetContainer.ClassCount; i++)
{
IFeatureClass pFeatureClass = datasetContainer.get_Class(i);
if (pFeatureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
m_FeatureLayer = new CadAnnotationLayerClass();
MessageBox.Show("");
}
else
{
m_FeatureLayer = new FeatureLayerClass();
m_FeatureLayer.Name = pFeatureClass.AliasName;
m_FeatureLayer.FeatureClass = pFeatureClass;
m_mapControl.Map.AddLayer(m_FeatureLayer);
}
}
}
//显示栅格图的方法
if ((select).type.StartsWith("r"))
{
IRasterDataset queryData = (IRasterDataset)dBdata;
IRasterLayer pRasterLayer = new RasterLayerClass();
pRasterLayer.CreateFromDataset(queryData);
m_mapControl.Map.AddLayer(pRasterLayer as ILayer);
}
}
//MessageBox.Show(listView1.SelectedItems[0].Text);
}
public bool TryResolve(string name, Type type, out object instance)
{
var cacheKey = new NameAndType(name, type);
if (typeof(IEnumerable).IsAssignableFrom(type))
{
var enumerableCacheKey = new NameAndType($"{Constants.EnumerableSlot}{name}", typeof(IEnumerable <>).MakeGenericType(type.GetGenericArguments()));
if (_registrations.TryGetValue(enumerableCacheKey, out var enumerableList))
{
foreach (var entry in enumerableList)
{
instance = entry();
if (!_registrations.ContainsKey(cacheKey))
{
return(true); // nothing to merge
}
var merged = (IList)Instancing.CreateInstance(typeof(List <>).MakeGenericType(type.GetGenericArguments()));
foreach (var x in (IList)instance)
{
merged.Add(x);
}
if (_registrations.TryGetValue(cacheKey, out var singleList))
{
foreach (var y in singleList)
{
foreach (var x in (IList)y())
{
merged.Add(x);
}
break;
}
}
instance = merged;
return(true);
}
}
}
if (_registrations.TryGetValue(cacheKey, out var list))
{
foreach (var entry in list)
{
instance = entry();
return(true);
}
}
if (!type.IsAbstract)
{
instance = Instancing.CreateInstance(type, this);
if (instance != null)
{
return(true);
}
}
instance = _fallback?.GetService(type);
if (instance != null)
{
return(true);
}
instance = default;
return(false);
}
private static void CompareOldWay(NameAndType expectedField, PropertyInfo propertyInfo)
{
var foundAttributes = CustomAttributeData.GetCustomAttributes(propertyInfo)
.AsQueryable().OrderBy(a => a.ToString()).ToList();
Assert.AreEqual(expectedField.Attributes.Count, foundAttributes.Count(), "For Field: " + propertyInfo.Name);
if (foundAttributes.Count() > 0)
{
for (int j = 0; j < foundAttributes.Count(); j++)
{
Assert.AreEqual(expectedField.Attributes[j], foundAttributes[j].ToString(), "For Field: " + propertyInfo.Name);
}
}
}
public bool Match(NameAndType other)
{
return(Name == other.Name && IsCimObject == other.IsCimObject && Type.ToString() == other.Type.ToString());
}
