public void RunRegisteredInstancesTest()
{
Console.WriteLine("This is a test using a Container with registered instances for both Class One and Class Two.");
var ioc = new UnityContainer();
var classOne = new ClassOne {
SomeString = "Im Some Class!"
};
var classTwo = new ClassTwo {
SomeInt = 200
};
ioc.RegisterInstance(classOne);
ioc.RegisterInstance(classTwo);
ioc.RegisterType <IClassOne, ClassOne>();
ioc.RegisterType <IClassTwo, ClassTwo>();
var classThree = ioc.Resolve <ClassThree>();
Console.WriteLine("Calling class three the first time...");
classThree.ShowClasses();
Console.WriteLine("Calling class three the second time...");
classThree.ShowClasses();
ioc.Dispose();
}
public void Bool_property_is_mapped()
{
const bool expected = true;
var classOne = new ClassOne { BoolProperty = expected };
var classTwo = classOne.MapAs<ClassTwo>();
classTwo.BoolProperty.ShouldEqual(expected);
}
public void Int_property_is_mapped()
{
const int expected = 7;
var classOne = new ClassOne { IntProperty = expected };
var classTwo = classOne.MapAs<ClassTwo>();
classTwo.IntProperty.ShouldEqual(expected);
}
public void Common()
{
var obj = new ClassOne();
var code = obj.GetHashCode();
obj = new ClassOne();
var code2 = obj.GetHashCode();
Assert.AreEqual(code, code2);
obj = new ClassOne("哈哈");
var code3 = obj.GetHashCode();
var obj1 = new ClassOne("嘿嘿");
var code4 = obj1.GetHashCode();
Assert.AreNotEqual(code3, code4);
var obj2 = new ClassOne("嘿嘿");
var code5 = obj2.GetHashCode();
Assert.AreEqual(code4, code5);
Assert.IsTrue(obj1.Equals(obj2));
Assert.IsFalse(obj.Equals(obj2));
}
public void Named_property_is_mapped()
{
const string expected = "name";
var classOne = new ClassOne { NamedProperty = expected };
var classTwo = classOne.MapAs<ClassTwo>();
classTwo.NamedProperty.ShouldEqual(expected);
}
public ClassOne(string name)
{
this.Name = name;
this.Name2 = name;
this.Name3 = name;
this.One = new ClassOne();
}
public void Date_time_property_is_mapped()
{
var expected = new DateTime(1979, 6, 15);
var classOne = new ClassOne { DateTimeProperty = expected };
var classTwo = classOne.MapAs<ClassTwo>();
classTwo.DateTimeProperty.ShouldEqual(expected);
}
static void Main(string[] args)
{
ClassCode classCode1 = new ClassCode();
classCode1.GetHashCode();
System.Console.WriteLine(classCode1.GetHashCode());
Car car1 = new Car();
Car car2 = new Car();
System.Console.WriteLine(car1.GetHashCode());
System.Console.WriteLine(car2.GetHashCode());
car1.Go();
car2.Go();
Car car3 = new Car();
car3.Go();
System.Console.WriteLine(car1);
// Static memory
ClassOne.Hi();
// Instance memory
// ClassTwo.Hi(); // Can NOT use
ClassTwo two = new ClassTwo();
two.Hi();
}
public ActionResult DeleteConfirmed(int id)
{
ClassOne classOne = db.ClassOnes.Find(id);
db.ClassOnes.Remove(classOne);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public Program()
{
Class1 = new ClassOne()
{
SupportedFiles = new string[] { "Test", "Test" }
};
//class1.SupportedFiles[0] = "First";
//class1.SupportedFiles[1] = "Second";
}
public void TestTransposeBetweenTwoClasses()
{
ClassOne source = new ClassOne { Field1 = "Hello", Field2 = "World", Property1 = "Goodbye", Property2 = "Universe" };
ClassTwo target = source.Transpose<ClassOne, ClassTwo>();
Assert.AreEqual("Hello", target.Field1);
Assert.AreEqual("Universe", target.Property2);
}
public void doSomething(ClassOne myOtherClass)
{
if (myOtherClass.x != 5)
{
}
if (ClassOne.MyStaticInteger != 5)
{
}
}
public ActionResult Edit([Bind(Include = "ClassID,Name,MyAge")] ClassOne classOne)
{
if (ModelState.IsValid)
{
db.Entry(classOne).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(classOne));
}
//Not required to create property of ClassOne
//public ClassOne class1 { get; set; }
public Program()
{
//In this way, you can create instance of class.
ClassOne class1 = new ClassOne();
//Now with the help of instance of class, you can access all public properties of that class
class1.SupportedFiles = new string[] { "Test", "Test" };
//class1.SupportedFiles[0] = "First";
//class1.SupportedFiles[1] = "Second";
}
public ActionResult Create([Bind(Include = "ClassID,Name,MyAge")] ClassOne classOne)
{
if (ModelState.IsValid)
{
db.ClassOnes.Add(classOne);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(classOne));
}
void AMethod()
{
ClassOne c1 = new ClassOne();
// can access c1.x
// cannot access c1.y
// cannot access c1.z
// can call c1.MethodOne();
// cannot call c1.MethodTwo();
// cannot call c1.MethodThree();
}
public void Can_get_weak_DataMember()
{
var dto = new ClassOne();
var dataMemberAttr = dto.GetType().GetProperty("Id").GetWeakDataMember();
Assert.That(dataMemberAttr.Name, Is.Null);
dataMemberAttr = dto.GetType().GetProperty("List").GetWeakDataMember();
Assert.That(dataMemberAttr.Name, Is.EqualTo("listClassTwo"));
Assert.That(dataMemberAttr.Order, Is.EqualTo(1));
}
static void Main(string[] args)
{
var class0 = new ClassZero();
var class1 = new ClassOne();
var class2 = new ClassTwo();
var class3 = new ClassWithoutHello();
class2.DynamicCall(class0);
class2.DynamicCall(class3);
Console.ReadLine();
}
static void Main()
{
//[!] 다른 클래스의 멤버 호출
//[a] 스태틱 멤버 호출
ClassOne.Hi(); // "안녕하세요." 출력
ClassTwo.Hi(); // "반갑습니다." 출력
//[b] 인스턴스 멤버 호출: 클래스의 인스턴스 생성 => 개체(객체)
ClassTwo ct = new ClassTwo();
ct.Hello(); // "또 만나요." 출력
}
// GET: ClassOnes/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ClassOne classOne = db.ClassOnes.Find(id);
if (classOne == null)
{
return(HttpNotFound());
}
return(View(classOne));
}
public void serialize()
{
var classOne = new ClassOne {
Id = 1,
List = new List <ClassTwo> {
new ClassTwo {
Name = "Name One"
}, new ClassTwo {
Name = "Name Two"
}
}
};
Console.WriteLine(JsonSerializer.SerializeToString(classOne));
}
public void Json_Serialize_Should_Respects_DataContract_Name()
{
var classOne = new ClassOne {
Id = 1,
List = new List <ClassTwo> {
new ClassTwo {
Name = "Name One"
}, new ClassTwo {
Name = "Name Two"
}
}
};
Assert.That(JsonSerializer.SerializeToString(classOne), Is.EqualTo("{\"Id\":1,\"listClassTwo\":[{\"NewName\":\"Name One\"},{\"NewName\":\"Name Two\"}]}"));
}
public ActionResult About()
{
var testClass = new ClassOne();
testClass.Greetings();
testClass.CallLogger();
testClass.Greetings();
testClass.CallLogger();
ViewBag.Message = "Your application description page.";
return(View());
}
static void Main(string[] args)
{
Console.WriteLine($"{ClassOne.BlackboardProperty_Nom.Key} exist ? {blackboard.ContainsKey(ClassOne.BlackboardProperty_Nom)}");
Console.WriteLine($"{ClassTwo.BlackboardProperty_Vitesse.Key} exist ? {blackboard.ContainsKey(ClassTwo.BlackboardProperty_Vitesse)}");
var v1 = new ClassOne();
var v2 = new ClassTwo();
var v3 = new Class3();
Console.WriteLine($"{ClassOne.BlackboardProperty_Nom.Key} exist ? {blackboard.ContainsKey(ClassOne.BlackboardProperty_Nom)}");
Console.WriteLine($"{ClassTwo.BlackboardProperty_Vitesse.Key} exist ? {blackboard.ContainsKey(ClassTwo.BlackboardProperty_Vitesse)}");
var v4 = blackboard.Get(ClassOne.BlackboardProperty_Nom);
var v5 = blackboard.Get(ClassTwo.BlackboardProperty_Vitesse);
var v6 = blackboard.Get <double>("Class3.Altitude");
var v7 = blackboard.Get("Class3.Altitude");
Console.ReadKey();
}
private static void Main()
{
// "Read" an excel document and set properties in this class
var excelDoc = new ExcelDocument
{
SomeValue = "original Value",
SomeOtherValue = "original value"
};
// Instantiate the classes above so they can use the document without re-reading it
var class1 = new ClassOne(excelDoc);
var class2 = new ClassTwo(excelDoc);
// Output the original values of our document
Console.WriteLine(excelDoc);
// Have each class do their operations on the document
class1.DoSomethingWithExcelData();
class2.DoSomethingWithExcelData();
// Output the values again to show how the two independent classes
// manipulated the same document (and without reading it)
Console.WriteLine(excelDoc);
GetKeyFromUser("\nDone! Press any key to exit...");
}
public void Speed()
{
const int max = 1000000;
var obj0 = new ClassOne("哈哈");
Stopwatch s = new Stopwatch();
s.Restart();
for (var i = 0; i < max; i++)
{
var code = obj0.GetHashCode();
}
var elapsed0 = s.ElapsedMilliseconds;
var obj1 = new ClassOneCommon("哈哈");
s.Restart();
for (var i = 0; i < max; i++)
{
var code = obj1.GetHashCode();
}
var elapsed1 = s.ElapsedMilliseconds;
}
public void String_property_is_mapped()
{
const string expected = "string";
var classOne = new ClassOne { StringProperty = expected };
var classTwo = classOne.MapAs<ClassTwo>();
classTwo.StringProperty.ShouldEqual(expected);
}
public void Conversion_of_datetime_to_string_works()
{
var classOne = new ClassOne { DateTimeToStringTypeProperty = new DateTime(1979, 6, 15) };
var classTwo = classOne.MapAs<ClassTwo>();
classTwo.DateTimeToStringTypeProperty.ShouldEqual("6/15/1979 12:00:00 AM");
}
public void TestTransposeFailsWhenPropertyTypeMismatches()
{
ClassOne source = new ClassOne { Field1 = "Hello", Field2 = "World", Property1 = "Goodbye", Property2 = "Universe" };
source.Transpose<ClassOne, ClassFour>();
}
public void Returns_the_correct_type()
{
var classOne = new ClassOne();
var classTwo = classOne.MapAs<ClassTwo>();
classTwo.ShouldBeType<ClassTwo>();
}
public Program()
{
Class1 = new ClassOne();
Class1.SupportedFiles = new string[] { "Test", "Test" };
}
public static void test()
{
var displayMember = ClassOne.GetPropertyName(x => x.PropertyOne);
}
public void Conversion_of_unknown_object_to_string_gives_object_type_as_a_string()
{
var classOne = new ClassOne { ObjectToStringProperty = new Object() };
var classTwo = classOne.MapAs<ClassTwo>();
classTwo.ObjectToStringProperty.ShouldEqual("System.Object");
}
public void Conversion_of_uri_to_string_works()
{
var classOne = new ClassOne { UriToStringTypeProperty = new Uri("http://jaredmcguire.com/") };
var classTwo = classOne.MapAs<ClassTwo>();
classTwo.UriToStringTypeProperty.ShouldEqual("http://jaredmcguire.com/");
}
public string AddAssign(string Subject, string TeacherName,string Class)
{
if (Class == "1")
{
try
{
ClassOne a = new ClassOne();
a.Subject = Subject;
a.TeacherName = TeacherName;
mdc.ClassOnes.InsertOnSubmit(a);
mdc.SubmitChanges();
return "Subject Added and Teacher Assigned SuccessFull !!";
}
catch
{
return "Subject Already Exists !!";
}
}
else if (Class == "2")
{
try
{
ClassTwo a = new ClassTwo();
a.Subject = Subject;
a.TeacherName = TeacherName;
mdc.ClassTwos.InsertOnSubmit(a);
mdc.SubmitChanges();
return "Subject Added and Teacher Assigned SuccessFull !!";
}
catch
{
return "Subject Already Exists !!";
}
}
else if (Class == "3")
{
try
{
ClassThree a = new ClassThree();
a.Subject = Subject;
a.TeacherName = TeacherName;
mdc.ClassThrees.InsertOnSubmit(a);
mdc.SubmitChanges();
return "Subject Added and Teacher Assigned SuccessFull !!";
}
catch
{
return "Subject Already Exists !!";
}
}
else if (Class == "4")
{
try
{
ClassFour a = new ClassFour();
a.Subject = Subject;
a.TeacherName = TeacherName;
mdc.ClassFours.InsertOnSubmit(a);
mdc.SubmitChanges();
return "Subject Added and Teacher Assigned SuccessFull !!";
}
catch
{
return "Subject Already Exists !!";
}
}
else if (Class == "5")
{
try
{
ClassFive a = new ClassFive();
a.Subject = Subject;
a.TeacherName = TeacherName;
mdc.ClassFives.InsertOnSubmit(a);
mdc.SubmitChanges();
return "Subject Added and Teacher Assigned SuccessFull !!";
}
catch
{
return "Subject Already Exists !!";
}
}
else if (Class == "6")
{
try
{
ClassCoy a = new ClassCoy();
a.Subject = Subject;
a.TeacherName = TeacherName;
mdc.ClassCoys.InsertOnSubmit(a);
mdc.SubmitChanges();
return "Subject Added and Teacher Assigned SuccessFull !!";
}
catch
{
return "Subject Already Exists !!";
}
}
else if (Class == "7")
{
try
{
ClassSeven a = new ClassSeven();
a.Subject = Subject;
a.TeacherName = TeacherName;
mdc.ClassSevens.InsertOnSubmit(a);
mdc.SubmitChanges();
return "Subject Added and Teacher Assigned SuccessFull !!";
}
catch
{
return "Subject Already Exists !!";
}
}
else if (Class == "8")
{
try
{
ClassEight a = new ClassEight();
a.Subject = Subject;
a.TeacherName = TeacherName;
mdc.ClassEights.InsertOnSubmit(a);
mdc.SubmitChanges();
return "Subject Added and Teacher Assigned SuccessFull !!";
}
catch
{
return "Subject Already Exists !!";
}
}
else if (Class == "9")
{
try
{
ClassNine a = new ClassNine();
a.Subject = Subject;
a.TeacherName = TeacherName;
mdc.ClassNines.InsertOnSubmit(a);
mdc.SubmitChanges();
return "Subject Added and Teacher Assigned SuccessFull !!";
}
catch
{
return "Subject Already Exists !!";
}
}
else if (Class == "10")
{
try
{
ClassTen a = new ClassTen();
a.Subject = Subject;
a.TeacherName = TeacherName;
mdc.ClassTens.InsertOnSubmit(a);
mdc.SubmitChanges();
return "Subject Added and Teacher Assigned SuccessFull !!";
}
catch
{
return "Subject Already Exists !!";
}
}
return "Hi";
}
public void When_two_objects_have_the_same_nested_objects_it_should_not_throw()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var c1 = new ClassOne();
var c2 = new ClassOne();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action act = () => c1.ShouldBeEquivalentTo(c2);
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
act.ShouldNotThrow();
}
static string CalcDlg(ClassOne father, MyDlg @delegate) => @delegate(father);
public void Types_that_cannot_convert_are_ignored()
{
var classOne = new ClassOne { EventArgsToUriFailProperty = new EventArgs() };
var classTwo = classOne.MapAs<ClassTwo>();
classTwo.EventArgsToUriFailProperty.ShouldBeNull();
}
public void The_cache_increases_by_two_after_the_first_mapping()
{
var classOne = new ClassOne();
var classTwo = classOne.MapAs<ClassTwo>();
Map.Cache.Count.ShouldEqual(2);
}
public void The_cache_increases_by_one_after_mapping_with_an_unknow_type()
{
var classOneA = new ClassOne();
var classTwoA = classOneA.MapAs<ClassTwo>();
Map.Cache.Count.ShouldEqual(2);
var classOneB = new ClassOne();
var classThree = classOneB.MapAs<ClassThree>();
Map.Cache.Count.ShouldEqual(3);
}
public void The_cache_does_not_increases_after_mapping_with_know_types()
{
var classOneA = new ClassOne();
var classTwoA = classOneA.MapAs<ClassTwo>();
Map.Cache.Count.ShouldEqual(2);
var classOneB = new ClassOne();
var classTwoB = classOneB.MapAs<ClassTwo>();
Map.Cache.Count.ShouldEqual(2);
}
public void Conversion_of_int_to_string_works()
{
var classOne = new ClassOne { IntToStringTypeProperty = 123 };
var classTwo = classOne.MapAs<ClassTwo>();
classTwo.IntToStringTypeProperty.ShouldEqual("123");
}
public void When_two_objects_have_the_same_nested_objects_it_should_not_throw()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var c1 = new ClassOne();
var c2 = new ClassOne();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action act = () => c1.ShouldHave().AllProperties().IncludingNestedObjects().EqualTo(c2);
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
act.ShouldNotThrow();
}
public void When_a_property_of_a_nested_object_doesnt_match_it_should_clearly_indicate_the_path()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var c1 = new ClassOne();
var c2 = new ClassOne();
c2.RefOne.ValTwo = 2;
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action act = () => c1.ShouldHave().AllProperties().IncludingNestedObjects().EqualTo(c2);
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
act.ShouldThrow<AssertFailedException>()
.WithMessage("Expected property RefOne.ValTwo to be 2, but found 3", ComparisonMode.StartWith);
}
private void Next_Click(object sender, EventArgs e)
{
tabControl1.SelectedIndex = 1;
ClassOne.Focus();
}
