static void DoWork()
{
List <object>[] myList = new List <object> [4];
AClass aClass = new AClass();
BClass bClass = new BClass();
myList[0] = new List <object>()
{
"a", "b", "c", "d"
};
myList[1] = new List <object>()
{
"0", "1", "2", "3", "4"
};
myList[2] = new List <object>()
{
0, 1, 2
};
myList[3] = new List <object>()
{
aClass, bClass
};
List <List <object> > result = myList[0].Select(element => new List <object>()
{
element
}).ToList();
for (int i = 1; i < myList.Count(); i++)
{
result = CombineCollections(result, myList[i]).ToList();
}
PrintList(result);
}
public void CompatibleCopyTest()
{
var a = new AClass() { Property = "P" };
var b = new BClass();
EntityTools<AClass, BClass>.CopyTo(a, b);
Assert.AreEqual("P", b.Prop);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Code,DescriptionRU,DescriptionKK,DescriptionEN")] BClass bClass)
{
if (id != bClass.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(bClass);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BClassExists(bClass.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(bClass));
}
private void InitLogicData()
{
_currentModule = SerializedUtils.DeserializeObject <BModule>();
if (_currentModule == null)
{
_currentModule = new BModule();
//_currentModule.MainMethod = new BMain();
_currentModule.NamespacesList = new List <BNamespace>();
BNamespace bNamespace = new BNamespace();
BClass @class = new BClass();
//@class.NamespaceId = bNamespace.NamespaceId;
bNamespace.Classes.Add(@class);
_currentModule.NamespacesList.Add(bNamespace);
SerializedUtils.SerializeObject(this._currentModule);
}
_allNamespaceDic = new Dictionary <string, string>();
_currentClassDic = new Dictionary <string, string>();
_currentVariableDic = new Dictionary <string, string>();
_allNamespaceDic.Add("", "None");
for (int i = 0; i < _currentModule.NamespacesList.Count; i++)
{
_allNamespaceDic.Add(_currentModule.NamespacesList[i].NamespaceId, _currentModule.NamespacesList[i].NamespaceName);
}
BLogicEditorValue.Init();
}
static void Main(string[] args)
{
List <object>[] myList = new List <object> [4];
AClass aClass = new AClass();
BClass bClass = new BClass();
myList[0] = new List <object>()
{
"a", "b", "c", "d"
};
myList[1] = new List <object>()
{
"0", "1", "2", "3", "4"
};
myList[2] = new List <object>()
{
0, 1, 2
};
myList[3] = new List <object>()
{
aClass, bClass
};
List <List <object> > result = CombineArrayOfLists(myList);
PrintList(result);
}
public void SimpleObjectCopy()
{
// ARRAGE
BClass original = new BClass()
{
id = 69,
Age = 23,
Name = "Bloodthirst"
};
Stopwatch profile = new Stopwatch();
// ACT
profile.Start();
BClass copy = instanceCopier.Copy(original);
profile.Stop();
TestContext.Out.WriteLine($"Time for copying {nameof(BClass)} : { profile.ElapsedTicks } ticks = { profile.ElapsedMilliseconds } ms ");
// ASSERT
Assert.AreNotSame(original, copy);
Assert.AreEqual(original.id, copy.id);
Assert.AreEqual(original.Age, copy.Age);
Assert.AreSame(original.Name, copy.Name);
}
public static int test_0_fullaot_variant_iface()
{
var arr = new BClass [10];
var enumerable = (IEnumerable <AClass>)arr;
enumerable.GetEnumerator();
return(0);
}
public DemoClass()
{
AClass a = new AClass();
BClass b = new BClass();
Debug.Log(string.Format("aName:{0},parent:{1},id:{2}", a.aName, a.parentName, a.id));
Debug.Log(string.Format("bName:{0},parent:{1},id:{2}", b.bName, b.parentName, b.id));
}
public void ConvertableTest()
{
var b = new BClass();
EntityTools<BClass>.SetValue(b, "DateTime", false, DateTime.Now);
EntityTools<BClass>.SetValue(b, "Age", false, "12");
Assert.IsNotNull(b.DateTime);
Assert.AreEqual(12, b.Age);
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
BClass bClass = await db.BClasses.FindAsync(id);
db.BClasses.Remove(bClass);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public FrmMain()
{
InitializeComponent();
bClass = new BClass();
bClass.ProcessEvent += new ProcessEventHandle(bClass_ProcessEvent1);
Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
Control.CheckForIllegalCrossThreadCalls = false;
}
public Object RemoveUser([FromBody] ClassUser classuser)
{
Payload payload = BAccount.ConfirmToken(this.Request);
if (payload == null || (!payload.rol.Contains(3) && !payload.rol.Contains(6)))
{
return(new { result = false, info = "Não autorizado." });
}
return(BClass.RemoveUser(classuser.ClassID, classuser.UserID, payload.aud));
}
public Object PutProfile([FromBody] TblClasses editedclass)
{
Payload payload = BAccount.ConfirmToken(this.Request);
if (payload == null || (!payload.rol.Contains(3) && !payload.rol.Contains(6)))
{
return(new { result = false, info = "Não autorizado." });
}
return(BClass.EditClass(editedclass, payload.aud));
}
public Object Post([FromBody] TblEvaluations evaluation)
{
Payload payload = BAccount.ConfirmToken(this.Request);
if (payload == null || !payload.rol.Contains(2) || !BClass.HasUser(evaluation.ClassFK, payload.aud))
{
return(new { result = false, info = "Não autorizado." });
}
return(BEvaluation.CreateEvaluation(evaluation, payload.aud));
}
public Object SwitchActivity(int classid)
{
Payload payload = BAccount.ConfirmToken(this.Request);
if (payload == null || (!payload.rol.Contains(3) && !payload.rol.Contains(6)))
{
return(new { result = false, info = "Não autorizado." });
}
return(BClass.SwitchActivity(classid, payload.aud));
}
public void DictionaryCopy()
{
// ARRAGE
BClass c1 = new BClass()
{
id = 69,
Age = 23,
Name = "Bloodthirst"
};
BClass c2 = new BClass()
{
id = 420,
Age = 33,
Name = "Ketsueki"
};
Dictionary <int, BClass> dict = new Dictionary <int, BClass>()
{
{ 13, c1 },
{ 666, c2 }
};
Stopwatch profile = new Stopwatch();
// ACT
profile.Start();
Dictionary <int, BClass> copy = dictCopier.Copy(dict);
profile.Stop();
TestContext.Out.WriteLine($"Time for copying {nameof(Dictionary<int, BClass>)} : { profile.ElapsedTicks } ticks = { profile.ElapsedMilliseconds } ms ");
// ASSERT
Assert.AreNotSame(dict, copy);
Assert.AreEqual(dict.Count, copy.Count);
if (dict.Count != copy.Count)
{
return;
}
for (int i = 0; i < copy.Count; i++)
{
var k1 = dict.Keys.ElementAt(i);
var k2 = copy.Keys.ElementAt(i);
var v1 = dict.Values.ElementAt(i);
var v2 = copy.Values.ElementAt(i);
Assert.AreEqual(k1, k2);
Assert.AreNotSame(v1, v2);
}
}
public async Task <IActionResult> Create([Bind("Id,Code,DescriptionRU,DescriptionKK,DescriptionEN")] BClass bClass)
{
if (ModelState.IsValid)
{
_context.Add(bClass);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(bClass));
}
public void IgnoreCaseTest()
{
var a = new AClass() { A = "AValue" };
Assert.AreEqual("AValue", EntityTools<AClass>.GetValue(a, "A", false));
Assert.AreEqual(null, EntityTools<AClass>.GetValue(a, "a", false));
var b = new BClass();
EntityTools<AClass, BClass>.CopyTo(a, b);
Assert.AreEqual(null, EntityTools<BClass>.GetValue(b, "a", false));
EntityTools<AClass, BClass>.CopyTo(a, b, true);
Assert.AreEqual("AValue", EntityTools<BClass>.GetValue(b, "a", false));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,Code,Description")] BClass bClass)
{
if (ModelState.IsValid)
{
db.Entry(bClass).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(bClass));
}
public ServerPanel(BClass bclass, ABusinessServer server, int limitNum)
: this()
{
this.server = server;
serverName = server.GetType().Name;
//bclass.ProcessEvent += new GCL.Threading.ProcessEventHandle(bclass_ProcessEvent1);
server.ProcessEvent += new ProcessEventHandle(server_ProcessEvent1);
this.Enter += new EventHandler(ServerPanel_Enter);
this.bunStart.Enabled = true;
this.MAXLISTLINES = limitNum;
}
public Object ClassesPrimaryBySchool(int schoolid)
{
Payload payload = BAccount.ConfirmToken(this.Request);
if (payload == null || (!payload.rol.Contains(3) && !payload.rol.Contains(6)))
{
return(new { result = false, info = "Não autorizado." });
}
return(BClass.GetClassesPrimaryBySchool(schoolid));
}
public static int test_0_regress_1()
{
BIFace c = new BClass();
object o = c.AMethod();
if (!(o is long) || ((long)o != 0))
{
return(1);
}
return(0);
}
public Object ClassesByTeacher(int teacherid)
{
Payload payload = BAccount.ConfirmToken(this.Request);
if (payload == null || (!payload.rol.Contains(3) && !payload.rol.Contains(6) && !payload.rol.Contains(2)) || (payload.rol.Contains(2) && payload.aud != teacherid))
{
return(new { result = false, info = "Não autorizado." });
}
return(BClass.GetClassesByUser(teacherid));
}
public async Task <ActionResult> Create([Bind(Include = "Id,Code,Description")] BClass bClass)
{
if (ModelState.IsValid)
{
db.BClasses.Add(bClass);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(bClass));
}
public static void Main(string[] args)
{
AStruct a = new AStruct();
modify(ref a);
Console.WriteLine(a.x); //Êä³ö1
BClass b = new BClass();
modify(ref b);
Console.WriteLine(b.x); //Êä³ö0
}
public Object Profile(int classid)
{
Payload payload = BAccount.ConfirmToken(this.Request);
if (payload == null || payload.rol.Contains(4) ||
((payload.rol.Contains(1) || payload.rol.Contains(5) || payload.rol.Contains(2)) && !payload.cla.Contains(classid)))
{
return(new { result = false, info = "Não autorizado." });
}
return(BClass.GetClassProfile(classid));
}
public static void Main(string[] args)
{
customer obj = new customer("Barack", "Obama");
obj.AppendData();
Customer2.getdata();
Customer3 obj1 = new Customer3();
obj1.getData();
Name obj2 = new Name();
obj2.setName("Sharma");
obj2.setName("Aditya", "Sharma");
obj2.setName("Aditya", "N", "Sharma");
Rectangle obj3 = new Rectangle();
obj3.getdata2();
obj3.Display();
Father fObj = new Father();
fObj.FatherMethod();
//Here Child object can access both class methods
Child cObj = new Child();
cObj.FatherMethod();
cObj.ChildMethod();
IStudent obj5 = new StudentDetails();
obj5.print();
//IStudent a = new IStudent();
StudentDetails std = new StudentDetails();
std.print();
std.marks();
Console.ReadKey();
DClass d = new DClass();
d.GetInfo();
BClass b = new BClass();
b.GetInfo();
}
public void SomeMethod()
{
DoSomething();
ThreadPool.QueueUserWorkItem(delegate(object state)
{
BClass.WorkerMethod();
SomeOtherMethod();
});
DoSomethingElse();
}
public Object ClassesByStudent(int studentid)
{
Payload payload = BAccount.ConfirmToken(this.Request);
if (payload == null || payload.rol.Contains(2) || payload.rol.Contains(4) ||
(payload.rol.Contains(1) && payload.aud != studentid) ||
(payload.rol.Contains(5) && !BParenting.GetGuardians(studentid).Contains(payload.aud)))
{
return(new { result = false, info = "Não autorizado." });
}
return(BClass.GetClassesByUser(studentid));
}
public void HashCode_ObjectsDiffOrder_AreNotEqual()
{
// Arrange
var obj1 = new AClass("foo", 3);
var obj2 = new BClass(3, "foo");
// Act
var hash1 = obj1.GetHashCode();
var hash2 = obj2.GetHashCode();
// Assert
Assert.NotEqual(hash1, hash2);
}
//where
//id为primary key主键
public Task <int> SaveDataBClassAsync(BClass datacell)
{
if (datacell.ID != 0)
{
//返回
return(_database.UpdateAsync(datacell));
}
else
{
//
return(_database.InsertAsync(datacell));
}
}
public void ListCopy()
{
// ARRAGE
BClass c1 = new BClass()
{
id = 69,
Age = 23,
Name = "Bloodthirst"
};
BClass c2 = new BClass()
{
id = 420,
Age = 33,
Name = "Ketsueki"
};
List <BClass> lst = new List <BClass>()
{
c1,
c2
};
Stopwatch profile = new Stopwatch();
// ACT
profile.Start();
List <BClass> copy = listCopier.Copy(lst);
profile.Stop();
TestContext.Out.WriteLine($"Time for copying {nameof(List<BClass>)} : { profile.ElapsedTicks } ticks = { profile.ElapsedMilliseconds } ms ");
// ASSERT
Assert.AreNotSame(lst, copy);
Assert.AreEqual(lst.Count, copy.Count);
if (lst.Count != copy.Count)
{
return;
}
for (int i = 0; i < lst.Count; i++)
{
Assert.AreNotSame(lst[i], copy[i]);
}
CollectionAssert.AreNotEqual(lst, copy);
CollectionAssert.IsNotSubsetOf(lst, copy);
}
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
BClass bClass = await db.BClasses.FindAsync(id);
if (bClass == null)
{
return(HttpNotFound());
}
return(View(bClass));
}
public void TestCopyTo() {
{
bool errorThrown = false;
try {
Char[] c1 = new Char[2];
c1.CopyTo(null, 2);
} catch (ArgumentNullException) {
errorThrown = true;
}
Assert("#E61", errorThrown);
}
{
bool errorThrown = false;
try {
Char[] c1 = new Char[2];
Char[,] c2 = new Char[2,2];
c1.CopyTo(c2, 2);
} catch (ArgumentException) {
errorThrown = true;
}
Assert("#E62", errorThrown);
}
{
bool errorThrown = false;
try {
Char[,] c1 = new Char[2,2];
Char[] c2 = new Char[2];
c1.CopyTo(c2, -1);
} catch (RankException) {
errorThrown = true;
}
Assert("#E63", errorThrown);
}
{
bool errorThrown = false;
try {
Char[,] c1 = new Char[2,2];
Char[] c2 = new Char[2];
c1.CopyTo(c2, 2);
} catch (RankException) {
errorThrown = true;
}
Assert("#E64", errorThrown);
}
{
bool errorThrown = false;
try {
Char[] c1 = new Char[2];
Char[] c2 = new Char[2];
c1.CopyTo(c2, -1);
} catch (ArgumentOutOfRangeException) {
errorThrown = true;
}
Assert("#E65", errorThrown);
}
{
bool errorThrown = false;
try {
Char[] c1 = new Char[2];
Char[] c2 = new Char[2];
c1.CopyTo(c2, 3);
} catch (ArgumentException) {
errorThrown = true;
}
Assert("#E66", errorThrown);
}
{
bool errorThrown = false;
try {
Char[] c1 = new Char[2];
Char[] c2 = new Char[2];
c1.CopyTo(c2, 1);
} catch (ArgumentException) {
errorThrown = true;
}
Assert("#E67", errorThrown);
}
{
bool errorThrown = false;
try {
String[] c1 = new String[2];
// TODO: this crashes mono if there are null
// values in the array.
c1[1] = "hey";
c1[0] = "you";
Char[] c2 = new Char[2];
c2[1] = 'a';
c2[0] = 'z';
c1.CopyTo(c2, 0);
} catch (ArrayTypeMismatchException) {
errorThrown = true;
}
Assert("#E68", errorThrown);
}
Char[] orig = {'a', 'b', 'c', 'd'};
Char[] copy = new Char[10];
Array.Clear(copy, 0, copy.Length);
orig.CopyTo(copy, 3);
AssertEquals("#E69", (char)0, copy[0]);
AssertEquals("#E70", (char)0, copy[1]);
AssertEquals("#E71", (char)0, copy[2]);
AssertEquals("#E72", orig[0], copy[3]);
AssertEquals("#E73", orig[1], copy[4]);
AssertEquals("#E74", orig[2], copy[5]);
AssertEquals("#E75", orig[3], copy[6]);
AssertEquals("#E76", (char)0, copy[7]);
AssertEquals("#E77", (char)0, copy[8]);
AssertEquals("#E78", (char)0, copy[9]);
{
// The following is valid and must not throw an exception.
bool errorThrown = false;
try {
int[] src = new int [0];
int[] dest = new int [0];
src.CopyTo (dest, 0);
} catch (ArgumentException) {
errorThrown = true;
}
Assert("#E79", !errorThrown);
}
{
// bug #38812
bool errorThrown = false;
try {
CClass[] src = new CClass [] { new CClass () };
BClass[] dest = new BClass [1];
src.CopyTo (dest, 0);
} catch (ArrayTypeMismatchException) {
errorThrown = true;
}
Assert("#E80", errorThrown);
}
}
