public void TryGetValueTest()
{
var expected = RandomNumber();
int result;
Assert.False(_nullableDictionary.TryGetValue("1", out result));
_nullableDictionary.Add("1", expected);
Assert.True(_nullableDictionary.TryGetValue("1", out result));
Assert.AreEqual(expected, result);
}
public T Get([CanBeNull] string identifier)
{
if (_cache.TryGetValue(identifier, out var result))
{
return(result);
}
if (!_items.TryGetValue(identifier, out var item))
{
return(default);
/// <summary>
/// Retrieves the from-element represented by the given alias.
/// </summary>
/// <param name="aliasOrClassName">The alias by which to locate the from-element.</param>
/// <returns>The from-element assigned the given alias, or null if none.</returns>
public FromElement GetFromElement(string aliasOrClassName)
{
FromElement fromElement;
_fromElementByClassAlias.TryGetValue(aliasOrClassName, out fromElement);
if (fromElement == null && SessionFactoryHelper.IsStrictJPAQLComplianceEnabled)
{
fromElement = FindIntendedAliasedFromElementBasedOnCrazyJPARequirements(aliasOrClassName);
}
if (fromElement == null && _parentFromClause != null)
{
fromElement = _parentFromClause.GetFromElement(aliasOrClassName);
}
return(fromElement);
}
// This method collects rows into groups by the group-defining column. It is shared by
// both GroupBy overloads.
private NullableDictionary <object, List <int> > FindGroups(NamedList groupByColumn)
{
NullableDictionary <object, List <int> > groups = new NullableDictionary <object, List <int> >();
for (int r = 0; r < this.map.Count; r++)
{
int index = this.map[r];
object value = groupByColumn.GetItem(index);
List <int> members;
if (!groups.TryGetValue(value, out members))
{
members = new List <int>();
groups.Add(value, members);
}
members.Add(index);
}
return(groups);
}
/// <summary>
/// Converts the current IEnumerable to a tree structure.
/// </summary>
/// <typeparam name="T">
/// The type of the nodes.
/// </typeparam>
/// <param name="enumerable">
/// The IEnumerable from which a tree structure should be created.
/// </param>
/// <param name="comperator">
/// A comperator function which gets the parent of an element. (Return
/// null in case of root element).
/// </param>
/// <returns>
/// A tree structure containing elements from the current list.
/// </returns>
public static Tree <T> ToTree <T>(
this IEnumerable <T> enumerable, Func <T, T, bool> comperator)
{
NullableDictionary <T, List <T> > nodes =
new NullableDictionary <T, List <T> >();
List <T> list = enumerable.ToList();
foreach (T element in list)
{
T parent = list.FirstOrDefault(x => comperator(element, x));
List <T> tmp;
if (!nodes.TryGetValue(parent, out tmp))
{
nodes[parent] = tmp = new List <T>();
}
tmp.Add(element);
}
return(new Tree <T>(nodes));
}
/// <summary>解析响应</summary>
/// <param name="rs"></param>
/// <returns></returns>
protected virtual Packet ParseResponse(Packet rs)
{
var p = rs.IndexOf(NewLine4);
// 兼容某些非法响应
if (p < 0)
{
p = rs.IndexOf(NewLine3);
}
if (p < 0)
{
return(null);
}
var str = rs.ToStr(Encoding.ASCII, 0, p);
var lines = str.Split("\r\n");
// HTTP/1.1 502 Bad Gateway
var ss = lines[0].Split(" ");
if (ss.Length < 3)
{
return(null);
}
// 分析响应码
var code = StatusCode = ss[1].ToInt();
//if (code == 302) return null;
if (code != 200)
{
throw new Exception($"{code} {ss.Skip(2).Join(" ")}");
}
// 分析头部
var hs = new NullableDictionary <String, String>(StringComparer.OrdinalIgnoreCase);
foreach (var item in lines)
{
var p2 = item.IndexOf(':');
if (p2 <= 0)
{
continue;
}
var key = item.Substring(0, p2);
var value = item.Substring(p2 + 1).Trim();
hs[key] = value;
}
Headers = hs;
var len = -1;
if (hs.TryGetValue("Content-Length", out str))
{
len = str.ToInt(-1);
}
ContentLength = len;
if (hs.TryGetValue("Connection", out str) && str.EqualIgnoreCase("Close"))
{
Client.TryDispose();
}
return(rs.Slice(p + 4, len));
}
private IDictionary <String, Object> ParseObject()
{
var reader = _reader;
var dic = new NullableDictionary <String, Object>(StringComparer.OrdinalIgnoreCase);
while (true)
{
while (reader.NodeType == XmlNodeType.Comment || reader.NodeType == XmlNodeType.Whitespace)
{
reader.Skip();
}
if (reader.NodeType != XmlNodeType.Element)
{
break;
}
var name = reader.Name;
// 读取属性值
if (reader.HasAttributes)
{
reader.MoveToFirstAttribute();
do
{
dic[reader.Name] = reader.Value;
} while (reader.MoveToNextAttribute());
}
else
{
reader.ReadStartElement();
}
while (reader.NodeType == XmlNodeType.Whitespace)
{
reader.Skip();
}
// 遇到下一层节点
Object val = null;
if (reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.Comment)
{
val = ParseObject();
}
else if (reader.NodeType == XmlNodeType.Text)
{
val = reader.ReadContentAsString();
}
// 如果该名字两次或多次出现，则认为是数组
if (dic.TryGetValue(name, out var val2))
{
if (val2 is IList <Object> list)
{
list.Add(val);
}
else
{
dic[name] = new List <Object> {
val2, val
}
};
}
else
{
dic[name] = val;
}
if (reader.NodeType == XmlNodeType.Attribute)
{
reader.Read();
}
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
while (reader.NodeType == XmlNodeType.Whitespace)
{
reader.Skip();
}
}
return(dic);
}