// public int itemCount = 10, columnCount = 1;
// void Start()
// {
// Dictionary<string, string> dict = new Dictionary<string, string> ();
// dict.Add ("1", "assdsdasd");
// dict.Add ("2", "bytyter");
// dict.Add ("3", "trwegvbtrw");
// dict.Add ("4", "45123412");
// dict.Add ("5", "tgtv52345");
// dict.Add ("6", "4321fff43214");
// dict.Add ("7", "123412f43");
// SetData (null, dict);
// }
public void SetData(Action<string> onItemClickAction, Dictionary<string, string> objects)
{
int itemCount = objects.Count;
int columnCount = 1;
items = new List<GameObject> (columnCount);
RectTransform rowRectTransform = itemPrefab.GetComponent<RectTransform> ();
RectTransform containerRectTransform = gameObject.GetComponent<RectTransform> ();
//calculate the width and height of each child item.
float width = containerRectTransform.rect.width / columnCount;
float ratio = width / rowRectTransform.rect.width;
float height = rowRectTransform.rect.height * ratio;
int rowCount = itemCount / columnCount;
if (itemCount % rowCount > 0)
rowCount++;
//adjust the height of the container so that it will just barely fit all its children
float scrollHeight = height * rowCount;
containerRectTransform.offsetMin = new Vector2 (containerRectTransform.offsetMin.x, -scrollHeight / 2);
containerRectTransform.offsetMax = new Vector2 (containerRectTransform.offsetMax.x, scrollHeight / 2);
int j = 0;
for (int i = 0; i < itemCount; i++) {
//this is used instead of a double for loop because itemCount may not fit perfectly into the rows/columns
if (i % columnCount == 0)
j++;
//create a new item, name it, and set the parent
GameObject newItem = Instantiate (itemPrefab) as GameObject;
newItem.name = gameObject.name + " item at (" + i + "," + j + ")";
newItem.transform.SetParent(gameObject.transform);
Text textField = newItem.GetComponentsInChildren<Text> (true)[0];
KeyValuePair<string, string> o = objects.ElementAt(i);//.Keys.ElementAt2(i);
textField.text = o.Value;
if (onItemClickAction != null) {
newItem.GetComponents<Button>()[0].onClick.AddListener (() => {onItemClickAction(o.Key);});
}
items.Add(newItem);
//move and size the new item
RectTransform rectTransform = newItem.GetComponent<RectTransform> ();
float x = -containerRectTransform.rect.width / 2 + width * (i % columnCount);
float y = containerRectTransform.rect.height / 2 - height * j;
rectTransform.offsetMin = new Vector2 (x, y);
x = rectTransform.offsetMin.x + width;
y = rectTransform.offsetMin.y + height;
rectTransform.offsetMax = new Vector2 (x, y);
}
}
public void TestReader_FromFactory()
{
string filepath = this.WriteTextToTempFile(Consts.ResxSample01, ".resx");
using (ILocanReader reader = LocanReaderWriterFactory.Instance.GetReader(new { filepath = filepath })) {
Dictionary<string, string> expectedValues = new Dictionary<string, string>();
expectedValues.Add("Key01", "Value01");
expectedValues.Add("Key02", "Value02");
expectedValues.Add("Key03", "Value03");
int currentIndex = 0;
foreach (ILocanRow row in reader.GetRowsToBeTranslated()) {
string expectedKey = expectedValues.ElementAt(currentIndex).Key;
string expectedValue = expectedValues.ElementAt(currentIndex).Value as string;
Assert.AreEqual(expectedKey, row.Id);
Assert.AreEqual(expectedValue, row.StringToTranslate);
currentIndex++;
}
}
}
//Given a sequence of non-negative integers find a subsequence of length 3 having maximum product with the numbers of the subsequence being in ascending order.
//Example:
//Input: 6 7 8 1 2 3 9 10
//Ouput: 8 9 10
//Wrong!!!
public List<int> Max(int[] a)
{
Dictionary<List<int>, int> result = new Dictionary<List<int>, int>();
List<int> list = new List<int>();
list.Add(a[0]);
result.Add(list, a[0]);
int max = 0, min = 0;
for (int i = 1; i < a.Length; i++)
{
min = result.Values.Min();
max = result.Values.Max();
if (a[i] >= max)
{
list = result.FirstOrDefault(x => x.Value == max).Key;
list.Add(a[i]);
result[list] = a[i];
if (list.Count > 3)
list.RemoveAt(0);
}
else if (a[i] <= min)
{
list = new List<int>();
list.Add(a[i]);
result.Add(list, a[i]);
}
else
{
for(int x=0;x<result.Count;x++)
{
var t = result.ElementAt(x);
if (t.Value < a[i])
{
t.Key.Add(a[i]);
result[t.Key] = a[i];
if (t.Key.Count > 3)
t.Key.RemoveAt(0);
}
}
}
}
max = result.Values.Max();
list = result.FirstOrDefault(x => x.Value == max).Key;
return list;
}
static void MyRemoveduplicate(int seed)
{
//其实用字典更好，应该字典可以保证没有重复的值
//.NET如果添加重复的键会抛异常(Fuck)
//JAVA会覆盖具有相同键的值
Dictionary<int, int> dic = new Dictionary<int, int>();
Random rm = new Random(seed);
int RmNum = 10;
while (RmNum > dic.Count)
{
int nValue = rm.Next(20);
if (dic.ContainsKey(nValue))
continue;
dic.Add(nValue, nValue);
}
for (int i = 0; i < dic.Count; i++)
{
Console.Write(dic.ElementAt(i).Value+" ");
}
Console.Write("\n");
}
public void loadLocalData()
{
Dictionary<string, Task> loadedTasks = null;
TasksDict = null;
FileStream fs = new FileStream(path, FileMode.Open);
try
{
BinaryFormatter formatter = new BinaryFormatter();
loadedTasks = (Dictionary<string, Task>)formatter.Deserialize(fs);
TasksDict = loadedTasks;
}
catch (SerializationException e)
{
Console.WriteLine("Failed to deserialize. Reason: " + e.Message);
throw;
}
finally
{
//selectedTask = TasksDict.ElementAt(0).Value;
user = TasksDict.ElementAt(0).Value.executor;
fs.Close();
}
}
public static void SetDefaultGrabber()
{
GUIDialogMenu dlg = (GUIDialogMenu)GUIWindowManager.GetWindow((int)Window.WINDOW_DIALOG_MENU);
if (dlg == null)
{
return;
}
dlg.Reset();
dlg.SetHeading(1263); // menu
// read index file
if (!File.Exists(_grabberIndexFile))
{
GUIDialogOK dlgOk = (GUIDialogOK)GUIWindowManager.GetWindow((int)Window.WINDOW_DIALOG_OK);
dlgOk.SetHeading(257);
dlgOk.SetLine(1, GUILocalizeStrings.Get(1261)); // No grabber index found
dlgOk.DoModal(GUIWindowManager.ActiveWindow);
return;
}
_grabberList = new Dictionary<string, ComboBoxItemDatabase>();
Directory.CreateDirectory(IMDB.ScriptDirectory);
DirectoryInfo di = new DirectoryInfo(IMDB.ScriptDirectory);
FileInfo[] fileList = di.GetFiles("*.csscript", SearchOption.AllDirectories);
GUIWaitCursor.Show();
foreach (FileInfo f in fileList)
{
try
{
CSScript.GlobalSettings.AddSearchDir(AppDomain.CurrentDomain.BaseDirectory);
using (AsmHelper script = new AsmHelper(CSScript.Compile(f.FullName), "Temp", true))
{
script.ProbingDirs = CSScript.GlobalSettings.SearchDirs.Split(';');
IIMDBScriptGrabber grabber = (IIMDBScriptGrabber) script.CreateObject("Grabber");
ComboBoxItemDatabase item = new ComboBoxItemDatabase();
item.Database = Path.GetFileNameWithoutExtension(f.FullName);
item.Language = grabber.GetLanguage();
item.Limit = IMDB.DEFAULT_SEARCH_LIMIT.ToString();
item.Name = grabber.GetName();
_grabberList.Add(item.Database, item);
}
}
catch (Exception ex)
{
Log.Error("Script grabber error file: {0}, message : {1}", f.FullName, ex.Message);
}
}
string defaultDatabase = string.Empty;
int defaultIndex = 0;
int dbNumber;
using (Profile.Settings xmlreader = new MPSettings())
{
defaultDatabase = xmlreader.GetValueAsString("moviedatabase", "database" + 0, "IMDB");
dbNumber = xmlreader.GetValueAsInt("moviedatabase", "number", 0);
}
foreach (KeyValuePair<string, ComboBoxItemDatabase> grabber in _grabberList)
{
dlg.Add(grabber.Value.Name + " - " + grabber.Value.Language);
if (defaultDatabase == grabber.Key)
{
dlg.SelectedLabel = defaultIndex;
}
else
{
defaultIndex++;
}
}
GUIWaitCursor.Hide();
dlg.DoModal(GUIWindowManager.ActiveWindow);
if (dlg.SelectedId == -1)
{
return;
}
using (Profile.Settings xmlwriter = new MPSettings())
{
KeyValuePair<string, ComboBoxItemDatabase> grabber = _grabberList.ElementAt(dlg.SelectedLabel);
if (grabber.Key != "IMDB")
{
if (dbNumber == 0)
{
dbNumber = 1;
}
xmlwriter.SetValue("moviedatabase", "number", dbNumber);
xmlwriter.SetValue("moviedatabase", "database" + 0, grabber.Key);
xmlwriter.SetValue("moviedatabase", "title" + 0, grabber.Value.Name);
xmlwriter.SetValue("moviedatabase", "language" + 0, grabber.Value.Language);
xmlwriter.SetValue("moviedatabase", "limit" + 0, 25);
}
else
{
for (int i = 0; i < 4; i++)
{
xmlwriter.SetValue("moviedatabase", "number", 0);
xmlwriter.RemoveEntry("moviedatabase", "database" + i);
xmlwriter.RemoveEntry("moviedatabase", "title" + i);
xmlwriter.RemoveEntry("moviedatabase", "language" + i);
xmlwriter.RemoveEntry("moviedatabase", "limit" + i);
}
}
}
IMDB.MovieInfoDatabase.ResetGrabber();
}
static void Main(string[] args)
{
// Даны два неубывающих массива x и y. Найти их пересечение, то есть неубывающий массив z, содержащий их общие элементы,
//причем кратность каждого элемента в массиве z равна минимуму его кратностей в массивах x и y.
const int firstLength = 7;
const int secondLength = 6;
float[] firstArray = new float[firstLength] { 1, 3, 4, 4, 5, 5, 5 };
float[] secondArray = new float[secondLength] { 1, 4, 4, 4, 5, 5 };
ArrayList thirdArray = new ArrayList();
//Словари для подсчета количества каждой цифры в соответствующем массиве
Dictionary<float, int> firstDict = new Dictionary<float, int>();
Dictionary<float, int> secondDict = new Dictionary<float, int>();
Program pr = new Program();
firstDict = pr.digitsAmountDict(firstArray, firstDict);
secondDict = pr.digitsAmountDict(secondArray, secondDict);
//Зная количество каждой цифры в обоих массивах, выводим в результирующий массив наименьшее их количество,
//и только тех, которые существуют в обоих массивах
for (int i = 0; i < firstDict.Count; i++)
{
for (int j = 0; j < secondDict.Count; j++)
{
var itemFirstDict = firstDict.ElementAt(i);
var itemSecondDict = secondDict.ElementAt(j);
if (itemFirstDict.Key == itemSecondDict.Key)
{
/*if (itemFirstDict.Value <= itemSecondDict.Value)
{
for (int k = 0; k < itemFirstDict.Value; k++)
{
thirdArray.Add(itemFirstDict.Key);
}
}
else
{
for (int l = 0; l < itemSecondDict.Value; l++)
{
thirdArray.Add(itemSecondDict.Key);
}
}*/
for (int k = 0; k < Math.Min(itemFirstDict.Value, itemSecondDict.Value); k++)
{
thirdArray.Add(itemSecondDict.Key);
}
}
}
}
Console.WriteLine("Элементы первого массива:");
for (int m = 0; m < firstArray.Length; m++)
{
Console.Write(" " + firstArray[m]);
}
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("Элементы второго массива:");
for (int m = 0; m < secondArray.Length; m++)
{
Console.Write(" " + secondArray[m]);
}
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("Элементы результирующего массива:");
for (int m = 0; m < thirdArray.Count; m++)
{
Console.Write(" " + thirdArray[m]);
}
Console.ReadKey();
}
/// <summary>
/// Machine minimization. EnableEvents must be used before to enable this method.
/// </summary>
public void Minimize()
{
bool hasMinimization = false;
#region Minimization
// find minimizable states
Dictionary<string, List<string>> minimizableStates = new Dictionary<string, List<string>>();
foreach (State s in this.States) {
foreach (State ss in this.States) {
if (ss.Name != s.Name) {
if (this.IsMirrorState(ss, s)) {
if (minimizableStates.Keys.Contains(s.Name))
minimizableStates[s.Name].Add(ss.Name);
else
minimizableStates.Add(s.Name, new List<string>() { ss.Name });
}
}
}
}
//update transitions
for (int i = 0; i < minimizableStates.Count - 1; i++) {
string stateName = minimizableStates.ElementAt(i).Key;
List<string> stateEquiv = minimizableStates.ElementAt(i).Value;
string newStateName = stateName;
foreach (string s in stateEquiv)
newStateName += "|" + s;
State mergedState = new State(newStateName);
minimizableStates.ElementAt(i).Value.Add(stateName);
foreach (string s in stateEquiv) {
minimizableStates.Remove(s);
State toRemove = (from State ss in this.States where ss.Name == s select ss).First();
foreach (Transition t in this.Transitions){
if (t.SourceState.Equals(toRemove))
t.SourceState = mergedState;
if (t.TargetState.Equals(toRemove))
t.TargetState = mergedState;
}
this.States.Remove(toRemove);
}
hasMinimization = true;
}
List<Transition> newTransitions = new List<Transition>();
foreach (Transition t in this.Transitions)
if (!newTransitions.Contains(t))
newTransitions.Add(t);
this.Transitions = newTransitions;
#endregion
//Re-apply minimination if machine has been modified
if (hasMinimization)
this.Minimize();
}
private void UpdateView()
{
var unitDict = new Dictionary<string, TestModel>();
var sections = from test in _sectionModel.Cast<TestModel>()
group test by test.MasterAgentIp
into unit
select new { unit.Key, Tests = unit };
foreach (var section in sections.ToList())
{
IList<TestModel> tests = section.Tests.OrderBy(t => t.TestId).ToList();
bool allGood = true;
var syndromSb = new StringBuilder();
foreach (TestModel test in tests)
{
if (test.Status != "Stan poprawny")
allGood = false;
syndromSb.Append(test.Status == "Stan poprawny" ? "0" : "1");
}
foreach (TestModel test in tests)
{
if (!unitDict.Keys.Contains(test.IpDest))
{
unitDict.Add(test.IpDest,
new TestModel
{
IpDest = test.IpDest,
MasterAgentIp = section.Key,
Status = "Stan poprawny"
});
}
else
{
unitDict[test.IpDest].Status = "Stan poprawny";
}
}
if (!allGood)
{
IList<SyndromModel> syndromList = _dataProvider.FindGlobalOpinion(section.Key);
bool opinionMatch = false;
foreach (
SyndromModel syndromModel in
syndromList.Where(syndromModel => SyndromsMatch(syndromModel.Syndrom, syndromSb.ToString()))
)
{
opinionMatch = true;
string[] failedHostsList = syndromModel.Hosts.TrimEnd(',').Split(',');
foreach (string host in failedHostsList)
{
unitDict[host].Status = "Stan NIEpoprawny";
}
}
if (!opinionMatch)
{
foreach (TestModel test in tests)
{
unitDict[test.IpDest].Status = "Brak pasującego syndromu";
}
}
}
}
for (int i = 0; i < unitDict.Count; i++)
{
unitDict.ElementAt(i).Value.TestId = i;
}
var groupedSectionModels = new ListCollectionView(_sectionModel);
groupedSectionModels.GroupDescriptions.Add(new PropertyGroupDescription("MasterAgentIp"));
var groupedUnitModels = new ListCollectionView(unitDict.Values.ToList());
groupedUnitModels.GroupDescriptions.Add(new PropertyGroupDescription("MasterAgentIp"));
UnitGrid.ItemsSource = groupedUnitModels;
SectionGrid.ItemsSource = groupedSectionModels;
}
public void ShowFilteredThumbnails(ObservableCollection<string> itemsToFilter)
{
Dictionary<string, string> categoryAndName = new Dictionary<string, string>();
List<string> gymnastValues = new List<string>();
List<string> locationValues = new List<string>();
List<string> vaultNumberValues = new List<string>();
List<string> dateValues = new List<string>();
List<decimal> eRatings = new List<decimal>();
List<decimal> dRatings = new List<decimal>();
for (int k = 0; k < itemsToFilter.Count; k++)
{
categoryAndName.Add(itemsToFilter[k].Split(':')[1], itemsToFilter[k].Split(':')[0]);
}
for (int j = 0; j < categoryAndName.Count; j++)
{
if (categoryAndName.ElementAt(j).Value.Equals("Gymnast"))
{
gymnastValues.Add(categoryAndName.ElementAt(j).Key);
}
else if (categoryAndName.ElementAt(j).Value.Equals("Location"))
{
locationValues.Add(categoryAndName.ElementAt(j).Key);
}
else if(categoryAndName.ElementAt(j).Value.Equals("Vault"))
{
vaultNumberValues.Add(categoryAndName.ElementAt(j).Key);
}
else if(categoryAndName.ElementAt(j).Value.Equals("Date"))
{
dateValues.Add(categoryAndName.ElementAt(j).Key);
}
}
List<vault> newVaults = vaultModule.filter(dRatings, eRatings, gymnastValues, locationValues, vaultNumberValues,dateValues);
modifyVaultVM.setData(newVaults);
OnPropertyChanged("ModifyViewModelControl");
}
/// <summary>
/// 订单商品添加页面
/// </summary>
/// <returns></returns>
public ActionResult OrderItemAddPage()
{
//搜索字段的下拉框
List<SelectListItem> listSearchProperty = new List<SelectListItem>();
Dictionary<string, string> dictionaryProperty = new Dictionary<string, string>();
dictionaryProperty.Add(LiveAzure.Resource.Model.Product.ProductInfoItem.Code,"Code");
dictionaryProperty.Add(LiveAzure.Resource.Model.Product.ProductOnItem.FullName,"FullName");
for (int i = 0; i < dictionaryProperty.Count; i++)
{
listSearchProperty.Add(new SelectListItem { Text = dictionaryProperty.ElementAt(i).Key, Value = dictionaryProperty.ElementAt(i).Value });
}
ViewBag.SearchProperty = listSearchProperty;
//搜索条件的下拉框
List<SelectListItem> listSearchMode = new List<SelectListItem>();
Dictionary<string, string> dictionaryModes = new Dictionary<string, string>();
dictionaryModes.Add("以...开头", "0");
dictionaryModes.Add("包含", "1");
dictionaryModes.Add("以...结尾", "2");
for (int i = 0; i < dictionaryModes.Count; i++)
{
listSearchMode.Add(new SelectListItem { Text = dictionaryModes.ElementAt(i).Key, Value = dictionaryModes.ElementAt(i).Value });
}
ViewBag.SearchMode = listSearchMode;
return View();
}
private void GenerateMethod(Type interfaceType, FieldBuilder handlerField, TypeBuilder typeBuilder) {
MetaDataFactory.Add(interfaceType);
// Obtém a lista de todos os métodos a serem criados.
MethodInfo[] interfaceMethods = interfaceType.GetMethods().OrderBy(p => p.Name).ToArray();
// Verifica se existe algum método a ser implementado na interface.
if (interfaceMethods != null) {
// Cria cada um dos métodos definidos na interface.
for (int i = 0; i < interfaceMethods.Length; i++) {
MethodInfo methodInfo = interfaceMethods[i];
// Obtém os parâmetros do método que está sendo criado.
ParameterInfo[] methodParams = methodInfo.GetParameters();
int numOfParams = methodParams.Length;
Type[] methodParameters = new Type[numOfParams];
// Armazena o tipo de cada parâmetro do método.
for (int j = 0; j < numOfParams; j++) {
methodParameters[j] = methodParams[j].ParameterType;
}
// Armazena todos os tipos genéricos do método.
Type[] genericArguments = methodInfo.GetGenericArguments();
MethodBuilder methodBuilder = null;
// Verifica se o método não possui tipos genéricos.
if (genericArguments.Length == 0) {
// Cria um MethodBuilder para o método da interface que esta sendo criado. Como não há tipos genéricos, a definição é feita em apenas uma etapa.
methodBuilder = typeBuilder.DefineMethod(
methodInfo.Name,
MethodAttributes.Public | MethodAttributes.Virtual,
CallingConventions.Standard,
methodInfo.ReturnType, methodParameters);
}
else {
// Cria um MethodBuilder que deverá ser preenchido em etapas, pois os tipos genéricos do método precisam ser identificados.
methodBuilder = typeBuilder.DefineMethod(
methodInfo.Name,
MethodAttributes.Public | MethodAttributes.Virtual,
CallingConventions.Standard);
// Define o tipo de retorno do método.
methodBuilder.SetReturnType(methodInfo.ReturnType);
Dictionary<int, string> typeParamNames = new Dictionary<int, string>();
Dictionary<int, Type> parameters = new Dictionary<int, Type>();
int currentIndex = 0;
// Analisa todos os parâmetros do método.
foreach (ParameterInfo parameterInfo in methodParams) {
// Caso o parâmetro não possua a propriedade FullName preenchida, indica que é um tipo genérico. Caso contrário, é um tipo forte.
if (parameterInfo.ParameterType.FullName == null) {
typeParamNames.Add(currentIndex, parameterInfo.ParameterType.Name);
}
else {
parameters.Add(currentIndex, parameterInfo.ParameterType);
}
currentIndex++;
}
// Verifica se existe algum tipo genérico.
if (typeParamNames.Count > 0) {
// Informa ao MethodBuilder os nomes dos tipos genéricos.
GenericTypeParameterBuilder[] typeParameters = methodBuilder.DefineGenericParameters(typeParamNames.Values.ToArray());
// Adiciona os tipos genéricos na lista de tipos do método.
for (int j = 0; j < typeParameters.Length; j++) {
int parameterIndex = typeParamNames.ElementAt(j).Key;
parameters.Add(parameterIndex, typeParameters[j]);
}
// Define o tipo de retorno do método.
methodBuilder.SetReturnType(methodInfo.ReturnType);
}
// Verifica se o tipo de retorno é um tipo genérico.
else if (methodInfo.ReturnType.IsGenericParameter == true) {
// Informa ao MethodBuilder o nome do tipo genérico.
GenericTypeParameterBuilder[] returnParameter = methodBuilder.DefineGenericParameters(methodInfo.ReturnType.Name);
// Define o tipo de retorno do método.
methodBuilder.SetReturnType(returnParameter[0]);
}
else {
// Informa ao MethodBuilder os nomes dos tipos genéricos.
methodBuilder.DefineGenericParameters(genericArguments.Select(p => p.Name).ToArray());
}
IEnumerable<Type> orderedParameters = parameters.OrderBy(p => p.Key).Select(p => p.Value);
// Informa ao MethodBuilder os nomes de todos os parâmetros do método.
methodBuilder.SetParameters(orderedParameters.ToArray());
}
#region( "Handler Method IL Code" )
bool hasReturnValue = (methodInfo.ReturnType.Equals(typeof(void)) == false);
ILGenerator methodIL = methodBuilder.GetILGenerator();
// Sempre declare um array para conter os parâmetros para o método a ser chamado pelo proxy.
methodIL.DeclareLocal(typeof(System.Object[]));
// Emite a declaração de uma variável local, caso exista um tipo de retorno para o método.
if (hasReturnValue == true) {
methodIL.DeclareLocal(methodInfo.ReturnType);
//if (methodInfo.ReturnType.IsValueType && (methodInfo.ReturnType.IsPrimitive == false)) {
// methodIL.DeclareLocal(methodInfo.ReturnType);
//}
}
// Cria um label para indicar onde o uso do proxy é iniciado.
Label handlerLabel = methodIL.DefineLabel();
// Cria um label para indicar onde está a saída do método (return).
Label returnLabel = methodIL.DefineLabel();
// Carrega "this" no stack.
methodIL.Emit(OpCodes.Ldarg_0);
// Carrega o handler para o proxy.
methodIL.Emit(OpCodes.Ldfld, handlerField);
// Caso exista um proxy, pula para o label que será utilizado para executá-lo.
methodIL.Emit(OpCodes.Brtrue_S, handlerLabel);
// Verifica se o método possui retorno.
if (hasReturnValue == true) {
// Caso seja um tipo primitivo apenas cria a variável de retorno, com o valor default do tipo.
if (methodInfo.ReturnType.IsValueType && methodInfo.ReturnType.IsPrimitive == false && methodInfo.ReturnType.IsEnum == false
&& (methodInfo.ReturnType.IsGenericType && methodInfo.ReturnType.GetGenericTypeDefinition() == typeof(Nullable<>)) == false) {
//methodIL.Emit(OpCodes.Ldloc_1);
methodIL.Emit(OpCodes.Ldloc_0);
}
// Caso o retorno seja uma classe, carrega nulo na variável de retorno.
else {
methodIL.Emit(OpCodes.Ldnull);
}
// Armazena o valor de retorno.
methodIL.Emit(OpCodes.Stloc_0);
// Passa para o fim do método.
//methodIL.Emit(OpCodes.Br_S, returnLabel);
methodIL.Emit(OpCodes.Br, returnLabel);
}
else {
// Passa para o fim do método.
//methodIL.Emit(OpCodes.Br_S, returnLabel);
methodIL.Emit(OpCodes.Br, returnLabel);
}
// Define o label que indica o início do trecho de execução do proxy.
methodIL.MarkLabel(handlerLabel);
// Carrega "this" no stack.
methodIL.Emit(OpCodes.Ldarg_0);
// Carrega o handler para o IDinamicProxy.
methodIL.Emit(OpCodes.Ldfld, handlerField);
// Carrega "this" no stack. Será utilizado para chamar o método GetMethod mais abaixo.
methodIL.Emit(OpCodes.Ldarg_0);
// Carrega o nome da interface no stack.
methodIL.Emit(OpCodes.Ldstr, interfaceType.FullName);
// Carrega o índice do método no stack.
methodIL.Emit(OpCodes.Ldc_I4, i);
// Executa o método GetMethod da classe MetaDataFactory, passando como parâmetros o nome da interface e o índice do método, carregados no stack.
methodIL.Emit(OpCodes.Call, typeof(MetaDataFactory).GetMethod("GetMethod", new Type[] { typeof(string), typeof(int) }));
// Carrega a quantidade de parâmetros do método no topo do stack.
methodIL.Emit(OpCodes.Ldc_I4, numOfParams);
// Cria um array de objetos. A quantidade de parâmetros carregados no stack é utilizado para definir o tamanho do array.
methodIL.Emit(OpCodes.Newarr, typeof(System.Object));
// Adiciona cada parâmetro existente na lista de parâmetros que serão utilizados ao invocar o método concreto.
if (numOfParams > 0) {
//methodIL.Emit(OpCodes.Stloc_1);
methodIL.Emit(OpCodes.Stloc_0);
for (int j = 0; j < numOfParams; j++) {
//methodIL.Emit(OpCodes.Ldloc_1);
methodIL.Emit(OpCodes.Ldloc_0);
methodIL.Emit(OpCodes.Ldc_I4, j);
methodIL.Emit(OpCodes.Ldarg, j + 1);
if (methodParameters[j].IsValueType) {
methodIL.Emit(OpCodes.Box, methodParameters[j]);
}
methodIL.Emit(OpCodes.Stelem_Ref);
}
//methodIL.Emit(OpCodes.Ldloc_1);
methodIL.Emit(OpCodes.Ldloc_0);
}
// Carrega a quantidade de argumentos genéricos para criar o próximo array.
methodIL.Emit(OpCodes.Ldc_I4, genericArguments.Length);
// Cria um array que conterá todos os tipos genéricos do método.
methodIL.Emit(OpCodes.Newarr, typeof(System.Type));
// Adicionamos o tipo de cada parâmetro genérico no array.
if (genericArguments.Length > 0) {
// Salva o array.
methodIL.Emit(OpCodes.Stloc_0);
// Obtém cada parâmetro genérico a ser adicionado.
for (int j = 0; j < genericArguments.Length; j++) {
// Carrega o array.
methodIL.Emit(OpCodes.Ldloc_0);
// Seleciona a posição j do array.
methodIL.Emit(OpCodes.Ldc_I4, j);
// Carrega o item a ser adicionado no array.
methodIL.Emit(OpCodes.Ldtoken, genericArguments[j]);
// Caso o parâmetro seja value type, é preciso fazer box.
if (genericArguments[j].IsValueType) {
methodIL.Emit(OpCodes.Box, genericArguments[j]);
}
// Insere o item no array.
methodIL.Emit(OpCodes.Stelem_Ref);
}
// Carrega o array preenchido, para que seja usado no método a seguir.
methodIL.Emit(OpCodes.Ldloc_0);
}
// Chama o método concreto através do Invoke.
methodIL.Emit(OpCodes.Callvirt, typeof(IDynamicProxy).GetMethod("Invoke"));
// Verifica se o método possui returno.
if (hasReturnValue == true) {
// Faz o unbox do valor de retorno, caso seja um valueType ou generic.
if (methodInfo.ReturnType.IsValueType == true || methodInfo.ReturnType.IsGenericParameter == true) {
methodIL.Emit(OpCodes.Unbox, methodInfo.ReturnType);
if (methodInfo.ReturnType.IsEnum) {
methodIL.Emit(OpCodes.Ldind_I4);
}
else if (methodInfo.ReturnType.IsPrimitive == false) {
methodIL.Emit(OpCodes.Ldobj, methodInfo.ReturnType);
}
else {
methodIL.Emit((OpCode)opCodeTypeMapper[methodInfo.ReturnType]);
}
}
else {
methodIL.Emit(OpCodes.Castclass, methodInfo.ReturnType);
}
// Armazena o valor retornado pelo método Invoke.
//methodIL.Emit(OpCodes.Stloc_0);
methodIL.Emit(OpCodes.Stloc_1);
// Pula para o label de saída do método.
//methodIL.Emit(OpCodes.Br_S, returnLabel);
methodIL.Emit(OpCodes.Br, returnLabel);
// Define o label para o ponto de saída do método;
methodIL.MarkLabel(returnLabel);
// Carrega o valor armazenado antes de retornar. Será nulo, caso não exista retorno, ou será o valor retornado pelo método Invoke.
//methodIL.Emit(OpCodes.Ldloc_0);
methodIL.Emit(OpCodes.Ldloc_1);
}
else {
// Como o método não possui retorno, remove qualquer valor armazenado antes de retornar.
methodIL.Emit(OpCodes.Pop);
// Define o label para o ponto de saída do método;
methodIL.MarkLabel(returnLabel);
}
// Define o ponto de saída do método (return);
methodIL.Emit(OpCodes.Ret);
#endregion
}
}
// Chama todas as demais interfaces herdadas pela interface atual, recursivamente.
foreach (Type parentType in interfaceType.GetInterfaces()) { GenerateMethod(parentType, handlerField, typeBuilder); }
}
public DictionaryEditorWindow(Dictionary<string, object> dictionary)
{
Value = dictionary;
Width = 415;
Height = 375;
this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
this.Text = "Настройки материала";
this.StartPosition = FormStartPosition.CenterScreen;
this.MaximizeBox = false;
this.MinimizeBox = false;
//
list = new TreeView();
list.Parent = this;
list.Width = 150;
list.Height = 300;
list.Left = 0;
list.Top = 0;
list.AfterSelect += list_AfterSelect;
//
grid = new PropertyGrid();
grid.Parent = this;
grid.Width = 250;
grid.Height = 300;
grid.Left = 150;
grid.Top = 0;
grid.PropertySort = PropertySort.NoSort;
grid.ToolbarVisible = false;
//
ok = new Button();
ok.Parent = this;
ok.Width = 100;
ok.Height = 24;
ok.Left = 290;
ok.Top = 305;
ok.Text = "OK";
ok.Visible = true;
ok.Click += ok_Click;
//
for (int i = 0; i < dictionary.Count; i++)
{
KeyValuePair<string, object> val = dictionary.ElementAt(i);
TreeNode node = list.Nodes.Add(val.Key + " (" + val.Value.GetType().Name + ")");
node.Tag = val.Key;
}
}
public static RuleMethod LocateMatchingRule(Dictionary<int, List<TokenResult>> buckets, ConversationContext context)
{
var Rules = new List<RuleMethod>();
//check our tokens against the rules
foreach (var rule in CommandRules)
{
//Console.WriteLine(rule.Name + " params:" + rule.GetParameters().Count().ToString());
//get the params of the method
var parameters = (from p in rule.GetParameters()
where p.ParameterType != typeof(ConversationContext)
select p).ToList();
int index = 0;
var parms = new List<TokenResult>();
//for each parm, see if the corresponding bucket has a token of that type
foreach (var parameterInfo in parameters)
{
Type searchType = parameterInfo.ParameterType;
TokenResult token = null;
if (buckets.Count > 0)
{
token = (from t in buckets.ElementAt(index).Value
where
t.Token.GetType() == searchType ||
t.Token.GetType().IsSubclassOf(searchType)
select t).FirstOrDefault();
if (searchType == typeof(TokenWhoWasIn) && token != null)
{
for (int i = index + 1; i < buckets.Count; i++)
{
foreach (var result in buckets.ElementAt(i).Value)
{
if (result.Token is TokenQuotedPhrase)
{
parms.Add(token);
parms.Add(result);
break;
}
}
}
break;
}
}
if (null != token)
{
parms.Add(token);
if (index < buckets.Count - 1)
{
index++;
}
else
{
break;
}
}
else
{
break;
}
}
if (parms.Count == parameters.Count() && parms.Count > 0)
{
var passins = new object[parms.Count + 1];
passins[0] = context;
for (int i = 1; i < parms.Count + 1; i++)
{
passins[i] = parms[i - 1].Token;
}
Rules.Add(new RuleMethod
{
PassIns = passins,
Rule = rule
});
}
}
RuleMethod ruleMethod = Rules.Where(r => r.PassIns.Count() == Rules.Max(s => s.PassIns.Count())).FirstOrDefault();
return ruleMethod;
}
public ActionResult UpdateScoreInTraineeTopic(Dictionary<string, object> model)
{
string status = string.Empty;
string message = string.Empty;
var DictraineeID = model.ElementAt(0);
string[] traineeID = (string[])DictraineeID.Value;
// var entity = new Tra_TraineeTopicEntity();
var lstEntity = new List<Tra_TraineeTopicEntity>();
var topicServices = new ActionService(UserLogin);
var objTopic = new List<object>();
objTopic.Add(null);
objTopic.Add(null);
objTopic.Add(null);
objTopic.Add(null);
objTopic.Add(1);
objTopic.Add(int.MaxValue - 1);
var lstTopic = topicServices.GetData<Cat_TopicEntity>(objTopic, ConstantSql.hrm_cat_sp_get_Topic, ref status).ToList();
var traineeScoreServices = new Tra_TraineeScoreServices();
var objTraineeScore = new List<object>();
objTraineeScore.Add(1);
objTraineeScore.Add(int.MaxValue - 1);
var lstTraineeScore = topicServices.GetData<Tra_TraineeScoreEntity>(objTraineeScore, ConstantSql.hrm_tra_sp_get_TraineeScore, ref status).ToList();
var scoreTopicServices = new ActionService(UserLogin);
var objScoreTopic = new List<object>();
objScoreTopic.Add(1);
objScoreTopic.Add(int.MaxValue - 1);
var lstScoreTopic = scoreTopicServices.GetData<Tra_ScoreTopicEntity>(objScoreTopic, ConstantSql.hrm_tra_sp_get_ScoreTopic, ref status).ToList();
var traineeTopicServices = new Tra_TraineeTopicServices();
var objTraineeTopic = new List<object>();
objTraineeTopic.Add(1);
objTraineeTopic.Add(int.MaxValue - 1);
var lstTraineeTopic = topicServices.GetData<Tra_TraineeTopicEntity>(objTraineeTopic, ConstantSql.hrm_tra_sp_get_TraineeTopic, ref status).ToList();
if (model.Count > 0)
{
for (int i = 3; i < model.Count; i++)
{
var entity = new Tra_TraineeTopicEntity();
var item = model.ElementAt(i);
var strTitle = item.Key.Split('_');
string[] score = (string[])item.Value;
var topicEnity = lstTopic.Where(s => item.Key.Contains(s.Code)).FirstOrDefault();
if (topicEnity != null)
{
var scoreTopicEntity = lstScoreTopic.Where(s => topicEnity.ID == s.TopicID && strTitle[1] == s.Code).FirstOrDefault();
var traineeTopicEntity = lstTraineeTopic.Where(s => s.TraineeID != null && topicEnity.ID == s.TopicID && Guid.Parse(traineeID[0]) == s.TraineeID.Value).FirstOrDefault();
if (traineeTopicEntity != null)
{
//Edit cột score trong bảng traineeTopic
if (!string.IsNullOrEmpty(score[0]))
{
traineeTopicEntity.Score = double.Parse(score[0]);
}
else {
traineeTopicEntity.Score = null;
}
message = traineeTopicServices.Edit(traineeTopicEntity);
//Kiểm tra trong bảng TraineeScoree. Nếu chưa có record thì tạo mới nguoc lai thì edit record
var traineeScoreEntity = lstTraineeScore.Where(s => s.TraineeTopicID == traineeTopicEntity.ID && scoreTopicEntity.ScoreTypeID == s.ScoreTypeID).FirstOrDefault();
if (traineeScoreEntity == null)
{
Tra_TraineeScoreEntity newTraineeScoreEntity = new Tra_TraineeScoreEntity();
newTraineeScoreEntity.ScoreTypeID = scoreTopicEntity.ScoreTypeID;
newTraineeScoreEntity.TraineeTopicID = traineeTopicEntity.ID;
newTraineeScoreEntity.Score = traineeTopicEntity.Score;
message = traineeScoreServices.Add(newTraineeScoreEntity);
}
else
{
traineeScoreEntity.Score = traineeTopicEntity.Score;
message = traineeScoreServices.Edit(traineeScoreEntity);
}
// lstEntity.Add(traineeTopicEntity);
}
}
}
//message = traineeTopicServices.Edit(lstEntity);
}
return null;
}
