//选择：选取数组中对象的某些成员形成一个独立的数组
//多个学生【id age tall score】 【60,50,70,80】
// 【“zs”，“ls”】
static public TKey[] Select <T, TKey>(T[] array, SelectHandler <T, TKey> handler)
{
TKey[] keys = new TKey[array.Length];
for (int i = 0; i < array.Length; i++)
{
keys[i] = handler(array[i]);
}
return(keys);
}
/// <summary>
/// 提取数组中每个元素的某个数据，组成新的数组
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TKey">提取数据的类型</typeparam>
/// <param name="array">源数据</param>
/// <param name="handler">提取的条件</param>
/// <returns>新数组</returns>
public static TKey[] Select <T, TKey>(T[] array, SelectHandler <T, TKey> handler)
{
TKey[] newArray = new TKey[array.Length];
for (int i = 0; i < array.Length; i++)
{
newArray[i] = handler(array[i]);
}
return(newArray);
}
public MobaClient(InitRequest initRequest) : base(initRequest)
{
account = new AccountHandler();
player = new PlayerHandler();
select = new SelectHandler();
fight = new FightHandler();
player.StartSelectEvent += select.StartSelect;
select.StartFightEvent = fight.StartFight;
}
public void AddReceiveSocket(Socket socket, SelectHandler handler)
{
if (socket == null || handler == null)
{
throw new ArgumentNullException();
}
receiveSockets.Add(socket);
map.Add(socket, handler);
}
public void UpdateConnectorToReceiver(Socket socket, SelectHandler handler)
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
connectList.Remove(socket);
receiveSockets.Add(socket);
map[socket] = handler;
}
public void AddConnectSocket(Socket socket, SelectHandler handler)
{
if (socket == null || handler == null)
{
throw new ArgumentNullException();
}
connectList.Add(socket);
map.Add(socket, handler);
}
public MobaClient(InitRequest initRequest) : base(initRequest)
{
Account = new AccountHandler();
Player = new PlayerHandler();
Select = new SelectHandler();
Fight = new FightHandler();
Player.StartSelectEvent = Select.StartSelect;
Select.StartFightEvent = Fight.StartSelect;
}
/// <summary>
/// 选择Select【6】：
/// 从对象集合中提取每个对象的某个属性的值做成一个新的数组
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TKey"></typeparam>
/// <param name="array"></param>
/// <param name="handler"></param>
/// <returns></returns>
public static TKey[] Select <T, TKey>(List <T> array,
SelectHandler <T, TKey> handler)
{
TKey[] arrarNew = new TKey[array.Count];
for (int i = 0; i < array.Count; i++)
{
arrarNew[i] = handler(array[i]);
}
return(arrarNew);
}
public MOBAClient(InitRequest initRequest) : base(initRequest)
{
accountHandler = new AccountHandler();
playerHandler = new PlayerHandler();
selectHandler = new SelectHandler();
battleHandler = new BattleHandler();
//添加事件监听
playerHandler.StartSelectAction = selectHandler.StartSelect;
selectHandler.StartBattleAction = battleHandler.StartBattle;
}
void Start()
{
if (GameObject.Find("NetWork") != null)
{
select = GameObject.Find("NetWork").GetComponent <SelectHandler>();
select.Talk = showMsg;
}
sendBtn.onClick.AddListener(delegate
{
sendClick();
});
}
void Awake()
{
if (GameObject.Find("NetWork") == null)
{
return;
}
selectHandler = GameObject.Find("NetWork").GetComponent <SelectHandler>();
if (selectHandler == null)
{
selectHandler = GameObject.Find("NetWork").AddComponent <SelectHandler>();
}
}
/// <summary>
/// Helper method for listen sockets. Automatically adds the new socket
/// to this class with the given handler.
/// </summary>
/// <param name="listenSocket"></param>
/// <param name="handler"></param>
public void PerformAccept(Socket listenSocket, SelectHandler handler)
{
Socket newReceiveSocket = listenSocket.Accept();
if (newReceiveSocket.Connected)
{
AddReceiveSocket(newReceiveSocket, handler);
}
else
{
newReceiveSocket.Close();
}
}
/// <summary>
/// 通过某种方式比出最大的元素
/// </summary>
/// <param name="array">数据源</param>
/// <param name="handler">比较条件</param>
/// <returns>找到的元素</returns>
public static T Max <T, TKey>(T[] array, SelectHandler <T, TKey> handler)
where TKey : IComparable, IComparable <TKey>
{
T max = array[0];
for (int i = 1; i < array.Length; i++)
{
if (handler(max).CompareTo(handler(array[i])) < 0)
{
max = array[i];
}
}
return(max);
}
/// <summary>
/// 找对象集合中最小的返回
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <typeparam name="TKey">数据类型的属性</typeparam>
/// <param name="array">数据类型的对象集合</param>
/// <param name="handler">委托：从对象中选择属性，返回属性的值！</param>
/// <returns>返回最大的</returns>
static public T Min <T, TKey>(T[] array, SelectHandler <T, TKey> handler)
where TKey : IComparable, IComparable <TKey>
{
//T max = default(T);
T min = array[0];
for (int i = 1; i < array.Length; i++)
{
if (handler(min).CompareTo(handler(array[i])) > 0)
{
min = array[i];
}
}
return(min);
}
/// <summary>
/// 2 返回最小对象
/// </summary>
/// <typeparam name="T">数据类型：如Student</typeparam>
/// <typeparam name="TKey">数据类型的字段的类型：如int</typeparam>
/// <param name="array">数据类型对象的数组</param>
/// <param name="handler">选择委托对象</param>
/// <returns>最大对象</returns>
static public T Min <T, TKey>(List <T> array,
SelectHandler <T, TKey> handler)
where TKey : IComparable <TKey>
{
var min = array[0];
for (int i = 1; i < array.Count; i++)
{
if (handler(min).CompareTo(handler(array[i])) > 0)
{
min = array[i];
}
}
return(min);
}
/// <summary>
/// 4 找最小 返回： 通用的+方便的+跨平台
/// </summary>
/// <typeparam name="T">数据类型 ：学生类</typeparam>
/// <typeparam name="TKey">数据类型的某个属性：学生的年龄或身高</typeparam>
/// <param name="array">数据类型的数组</param>
/// <param name="handler">从某个对象中 选取某个属性的值返回的委托</param>
public static T Min <T, TKey>
(T[] array, SelectHandler <T, TKey> handler)
where TKey : IComparable
{
T t = array[0];
for (int i = 1; i < array.Length; i++)
{
if ((handler(t).CompareTo(handler(array[i]))) > 0)
{
t = array[i];
}
}
return(t);
}
//升序排列
public static void OrderBy <T, TKey>(T[] array, SelectHandler <T, TKey> handler)
where TKey : IComparable <TKey>
{
for (int i = 0; i < array.Length - 1; i++)
{
for (int j = i + 1; j < array.Length; j++)
{
if (handler(array[i]).CompareTo(handler(array[j])) > 0)
{
var temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
}
/// <summary>
/// 3 返回最大的
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <typeparam name="TKey">数据类型字段的类型</typeparam>
/// <param name="array">数据类型对象的数组</param>
/// <param name="handler">
/// 委托对象：负责 从某个类型中选取某个字段 返回这个字段的值
/// </param>
static public T Max <T, TKey>
(T[] array, SelectHandler <T, TKey> handler)
where TKey : IComparable <TKey>
{
T temp = default(T);
temp = array[0];
for (int i = 1; i < array.Length; i++)
{
if (handler(temp).CompareTo(handler(array[i])) < 0)
{
temp = array[i];
}
}
return(temp);
}
/// <summary>
/// 对对象集合降序排列
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <typeparam name="TKey">数据类型的属性</typeparam>
/// <param name="array">数据类型的对象集合</param>
/// <param name="handler">委托：从对象中选择属性，返回属性的值！</param>
static public void OrderByDescending <T, TKey>(T[] array, SelectHandler <T, TKey> handler)
where TKey : IComparable, IComparable <TKey>
{
for (int i = 0; i < array.Length - 1; i++)
{
for (int j = i + 1; j < array.Length; j++)
{ //arrar[i]: int[],string[],Student[]>zs.age
//if (array[i].CompareTo(array[j]) > 0)
if (handler(array[i]).CompareTo(handler(array[j])) < 0)
{
var temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
}
/// <summary>
/// 2 降序排列： 通用的+方便的+跨平台
/// </summary>
/// <typeparam name="T">数据类型 ：学生类</typeparam>
/// <typeparam name="TKey">数据类型的某个属性：学生的年龄或身高</typeparam>
/// <param name="array">数据类型的数组</param>
/// <param name="handler">从某个对象中 选取某个属性的值返回的委托</param>
public static void OrderByDescending <T, TKey>
(T[] array, SelectHandler <T, TKey> handler)
where TKey : IComparable
{
for (int i = 0; i < array.Length; i++)
{
for (int k = i + 1; k < array.Length; k++)
{
if ((handler(array[i]).CompareTo(handler(array[k]))) < 0)
{
var temp = array[i];
array[i] = array[k];
array[k] = temp;
}
}
}
}
//Tkey float T CharacterState
//public static float Handler(CharacterState t)
//{
// return Vector3.
// Distance(skillTransform.position, p.transform.position);
//}
//绑定一个方法
public static void OrderBy <T, TKey>(T[] items,
SelectHandler <T, TKey> handler) where TKey : IComparable
{
T temp;
for (int i = 0; i < items.Length - 1; i++)
{
for (int n = i + 1; n < items.Length; n++)
{
if (handler(items[i]).CompareTo(handler(items[n])) > 0)
{
temp = items[i];
items[i] = items[n];
items[n] = temp;
}
}
}
}
//推导
//1实现 整数数组排序的方法 冒泡法
//static public void OrderBy1(int[] array)
//{
// for (int i = 0; i < array.Length; i++)
// {
// for (int j = i+1; j < array.Length; j++)
// {
// if (array[i].CompareTo(array[j]) > 0)
// {
// int temp = array[i];
// array[i] = array[j];
// array[j] = temp;
// }
// }
// }
//}
//static public void OrderBy2(string[] array)
//{
// for (int i = 0; i < array.Length; i++)
// {
// for (int j = i + 1; j < array.Length; j++)
// {
// if (array[i].CompareTo(array[j]) > 0)
// {
// var temp = array[i];
// array[i] = array[j];
// array[j] = temp;
// }
// }
// }
//}
//如果 需要比较对象的其它属性，还要引入一个参数，指明是哪个属性
//static public void OrderBy3<T>(T[] array) //用于整数，字符串，对象默认字段 数组比较
// where T:IComparable<T>
//{
// for (int i = 0; i < array.Length; i++)
// {
// for (int j = i + 1; j < array.Length; j++)
// {
// if (array[i].CompareTo(array[j]) > 0)
// {
// var temp = array[i];
// array[i] = array[j];
// array[j] = temp;
// }
// }
// }
//}
//static public void OrderBy3<T>(T[] array, IComparer<T> compare)
// where T : IComparable<T>//对象 非 默认字段 数组比较
//{
// for (int i = 0; i < array.Length; i++)
// {
// for (int j = i + 1; j < array.Length; j++)
// {
// //默认 张三 年龄 李四 年龄 if (array[i].CompareTo(array[j]) > 0)
// //非默认 张三 身高 李四 身高 if (compare.Compare(array[i],array[j])>0)
// if (compare.Compare(array[i],array[j])>0)
// {
// var temp = array[i];
// array[i] = array[j];
// array[j] = temp;
// }
// }
// }
//}
/// <summary>
/// 升序排序
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <typeparam name="TKey">数据类型字段的类型</typeparam>
/// <param name="array">数据类型对象的数组</param>
/// <param name="handler">
/// 委托对象：负责 从某个类型中选取某个字段 返回这个字段的值
/// </param>
static public void OrderBy <T, TKey>
(T[] array, SelectHandler <T, TKey> handler)
where TKey : IComparable <TKey>//对象 非 默认字段 数组比较
{
for (int i = 0; i < array.Length; i++)
{
for (int j = i + 1; j < array.Length; j++)
{
//默认 张三 年龄 李四 年龄 if (array[i].CompareTo(array[j]) > 0)
//非默认 张三 身高 李四 身高 if (compare.Compare(array[i],array[j])>0)
//使用委托取属性的值 去比较
if (handler(array[i]).CompareTo(handler(array[j])) > 0)
{
var temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
}
//冒泡
//public static void OrderBy(int[] array)
//{
// for (int i = 0; i < array.Length-1; i++)
// {
// for (int j =i+1; j < array.Length ; j++)
// {
// if (array[i].CompareTo(array[j]) > 0)
// {
// var temp = array[i];
// array[i] = array[j];
// array[j] = temp;
// }
// }
// }
//}
/// <summary>
///3 升序排序
/// </summary>
/// <typeparam name="T">数据类型：如Student</typeparam>
/// <typeparam name="TKey">数据类型的字段的类型：如int</typeparam>
/// <param name="array">数据类型对象的数组</param>
/// <param name="handler">选择委托对象</param>
public static void OrderBy <T, TKey>(List <T> array,
SelectHandler <T, TKey> handler)
where TKey : IComparable <TKey>
{
for (int i = 0; i < array.Count - 1; i++)
{
for (int j = i + 1; j < array.Count; j++)
{
//var tkey1 = handler(array[i]);
//var tkey2 = handler(array[j]);
//var re = tkey1.CompareTo(tkey2);
//if (array[i].CompareTo(array[j]) > 0)
if (handler(array[i]).CompareTo(handler(array[j])) > 0)
{
var temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
}
/// <summary>
/// 返回最小的
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <typeparam name="TKey">数据类型字段的类型</typeparam>
/// <param name="array">数据类型对象的数组</param>
/// <param name="handler">
/// 委托对象：负责 从某个类型中选取某个字段 返回这个字段的值
/// </param>
static public T Min <T, TKey>(T[] array, SelectHandler <T, TKey> handler) where TKey : IComparable <TKey>
{
T temp = default(T);
if (array != null && array.Length != 0)
{
temp = array[0];
}
else
{
return(temp);
}
for (int i = 1; i < array.Length; i++)
{
if (handler(temp).CompareTo(handler(array[i])) > 0)
{
temp = array[i];
}
}
return(temp);
}
private void Select_button_Click(object sender, EventArgs e)
{
SelectHandler?.Invoke(this, null);
Close();
}
protected override Expression VisitMethodCall(MethodCallExpression m)
{
if (m.Method.DeclaringType == typeof(Queryable))
{
switch (m.Method.Name)
{
case "Select":
Debug.Assert(selectHandler == null);
selectHandler =
SelectHandler.GetSelectHandler(indentLevel + 1, m, aggregateType);
if (selectHandler == null)
{
this.queryableMethods.Enqueue(m);
}
this.Visit(m.Arguments[0]);
break;
case "Join":
Debug.Assert(joinHandler == null);
Debug.Assert(crossJoinHandler == null);
joinHandler = JoinHandler.GetJoinHandler(this, indentLevel + 1, m);
break;
case "SelectMany":
Debug.Assert(crossJoinHandler == null);
Debug.Assert(joinHandler == null);
crossJoinHandler = CrossJoinHandler.GetCrossJoinHandler(this, indentLevel + 1, m);
break;
case "Where":
Debug.Assert(whereHandler == null);
int parameterBaseIndex = outerStatement == null ? 0 : outerStatement.ParameterCount;
whereHandler =
WhereHandler.GetWhereHandler(indentLevel + 1, m, parameterBaseIndex);
if (whereHandler == null)
{
this.queryableMethods.Enqueue(m);
}
this.Visit(m.Arguments[0]);
break;
case "OrderBy":
case "OrderByDescending":
case "ThenBy":
case "ThenByDescending":
var orderByHandler = OrderByHandler.GetOrderByHandler(indentLevel + 1, m);
if (orderByHandler == null)
{
this.queryableMethods.Enqueue(m);
}
else
{
orderByHandlers.Push(orderByHandler);
}
this.Visit(m.Arguments[0]);
break;
default:
queryableMethods.Enqueue(m);
this.Visit(m.Arguments[0]);
break;
}
}
else
{
throw new NotSupportedException(string.Format("The method '{0}' is not supported", m.Method.Name));
}
return m;
}
void Awake()
{
handler = GameObject.Find("NetWork").GetComponent <SelectHandler>();
hero = transform.Find("headBtn").GetComponent <Image>();
btn = transform.Find("headBtn").GetComponent <Button>();
}
private void InitSelectHandler()
{
if (selectHandler != null)
{
return;
}
if (joinHandler != null)
{
selectHandler = SelectHandler.GetSelectHandler(indentLevel + 1,
QueryableMethodsProvider.GetSelectCall(joinHandler.Selector),
AggregateType.None);
return;
}
if (crossJoinHandler != null)
{
selectHandler = SelectHandler.GetSelectHandler(indentLevel + 1,
QueryableMethodsProvider.GetSelectCall(crossJoinHandler.Selector),
AggregateType.None);
return;
}
Type returnType = GetReturnType();
if (returnType == null)
{
throw new InvalidOperationException("Cannot translate statement");
}
selectHandler = SelectHandler.GetSelectHandler(indentLevel + 1, returnType);
}
public static SelectHandler GetSelectHandler(int indentLevel,
MethodCallExpression expression,
AggregateType aggregateType)
{
Debug.Assert(expression.Method.Name == "Select");
Debug.Assert(expression.Arguments.Count == 2);
Debug.Assert(expression.Arguments[0].Type.GetGenericArguments().Length == 1);
var selector = GetLambdaExpression(expression.Arguments[1]).Parameters[0];
if (selector.Type.Name == "IGrouping`2")
{
return null;
}
SelectHandler selectHandler = new SelectHandler(indentLevel,
expression, aggregateType);
return selectHandler;
}
public string LoginUserAccount()
{
SelectHandler selectAccount = new SelectHandler();
return(selectAccount.SelectUserAccount(this));
}
public void Run()
{
control.RunThread = Thread.CurrentThread;
List <Socket> selectReadSockets = new List <Socket>();
List <Socket> connectSockets, errorSockets;
if (control.SupportsConnect)
{
connectSockets = new List <Socket>();
errorSockets = new List <Socket>();
}
else
{
connectSockets = null;
errorSockets = null;
}
while (true)
{
//
// Perform the select
//
selectReadSockets.Clear();
control.CopyReadSocketsTo(selectReadSockets);
if (connectSockets == null || !control.HasConnectSockets)
{
if (selectReadSockets.Count == 0)
{
return;
}
//Console.WriteLine("[DEBUG] Selecting on 0 connect sockets");
Socket.Select(selectReadSockets, null, null, Int32.MaxValue);
}
else
{
connectSockets.Clear();
errorSockets.Clear();
control.CopyConnectSocketsTo(connectSockets);
control.CopyConnectSocketsTo(errorSockets);
if (selectReadSockets.Count == 0 && connectSockets.Count == 0)
{
return;
}
//Console.WriteLine("[DEBUG] Selecting on {0} connect sockets", connectSockets.Count);
Socket.Select(selectReadSockets, connectSockets, errorSockets, Int32.MaxValue);
control.ConnectionError = true;
for (int i = 0; i < errorSockets.Count; i++)
{
Socket socket = errorSockets[i];
SelectHandler handler = control.TryGetHandler(socket);
if (handler != null)
{
handler(ref control, socket, safeBuffer);
}
}
control.ConnectionError = false;
for (int i = 0; i < connectSockets.Count; i++)
{
Socket socket = connectSockets[i];
// Make sure you don't call the handler twice
if (!errorSockets.Contains(socket))
{
SelectHandler handler = control.TryGetHandler(socket);
if (handler != null)
{
handler(ref control, socket, safeBuffer);
}
}
}
}
for (int i = 0; i < selectReadSockets.Count; i++)
{
Socket socket = selectReadSockets[i];
SelectHandler handler = control.TryGetHandler(socket);
if (handler != null)
{
handler(ref control, socket, safeBuffer);
}
}
}
}
