static void Main()
{
new FirstClass(); //instance will be stored in static singleton
SecondClass second_class = new SecondClass();
second_class.DoSomethingWithFirstClass()
}
public static async System.Threading.Tasks.Task FirstClassMethod()
{
return(await Task.WhenAll(
SecondClass.SecondClassMethod(),
ThirdClass.ThirdClassMethod()
));
}
public ActionResult Create(SecondClass instance)
{
// Add new instance to database
_db.SecondClasses.Add(instance);
_db.SaveChanges();
return(RedirectToAction("Index"));
}
public static void Main(string[] args)
{
Clock clock = new Clock();
FirstClass s1 = new FirstClass();
SecondClass s2 = new SecondClass();
ThirdClass s3 = new ThirdClass();
s1.Register(clock);
s2.Register(clock);
clock.Countdown(2500);
clock.Countdown(6000);
s3.Register(clock);
clock.Countdown(4000);
s3.Unregister(clock);
clock.Countdown(4000);
Console.ReadLine();
foreach (var item in Fibonacci.Fibonaccis(21))
{
Console.WriteLine(item);
}
int i = BinarrySearch.Search(new dynamic[] { 4, 6, 43, 234, 733.5, 4223, 42523 }, 4);
Console.WriteLine(i);
char[] strs = "АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ".ToCharArray();
int y = BinarrySearch.Search(strs, 'Я');
Console.WriteLine(y);
Console.ReadLine();
}
static void Main(string[] args)
{
var converter = WombatConverter.CreateInitialized();
int number = converter.Convert <string, int>("923");
string numbetToString = converter.Convert(number, string.Empty);
Console.WriteLine(number);
Console.WriteLine(numbetToString);
converter = WombatConverter.CreateEmpty();
converter.Register <FirstClass, SecondClass>(
firstClass =>
{
return(new SecondClass
{
Age = firstClass.Age,
NameAndAge = string.Format("{0} are {1} years old",
firstClass.Name, firstClass.Age)
});
});
SecondClass secondClass =
converter.Convert <FirstClass, SecondClass>(new FirstClass {
Age = 11, Name = "John"
});
Console.WriteLine("Age: " + secondClass.Age);
Console.WriteLine("NameAndAge: " + secondClass.NameAndAge);
Console.ReadKey();
}
public string ConsumeStringFromSecondPackage()
{
var second = new SecondClass();
var secondString = second.GetSecondString();
return($"consumed-by-class-two:{secondString}");
}
public void Demo12()
{
SecondClass sc = new SecondClass();
BaseClass bc = (BaseClass)sc;
bc.Print();
}
public void MultiChain()
{
var a = new FirstClass().GoToSecondClass();
var b = new SecondClass().GoToThirdClass();
var c = new SecondClass().thirdClass;
var d = a.IntFieldSC;
}
static void Main()
{
new FirstClass(); //it just updates static data
SecondClass second_class = new SecondClass();
second_class.DoSomethingWithStaticDataOfFirstClass()
}
static void Test()
{
PrintAuthorInfo(typeof(FirstClass));
PrintAuthorInfo(typeof(SecondClass));
PrintAuthorInfo(typeof(ThirdClass));
SecondClass f = new SecondClass();
}
protected override void Because_of()
{
var source = new FirstClass
{
EnumValue = FirstEnum.NamedEnum
};
_result = Mapper.Map<FirstClass, SecondClass>(source);
}
protected override void Because_of()
{
var source = new FirstClass {
EnumValue = FirstEnum.NamedEnum
};
_result = Mapper.Map <FirstClass, SecondClass>(source);
}
static void Main(string[] args)
{
FirstClass fc = new FirstClass();
fc.DisplayHello();
SecondClass sc = new SecondClass();
sc.DisplayHello();
}
static void Main(string[] args)
{
var faker = new Faker();
FirstClass firstClass = faker.Create <FirstClass>();
SecondClass secondClass = faker.Create <SecondClass>();
Console.WriteLine(JsonSerializer.Serialize(firstClass));
Console.WriteLine(JsonSerializer.Serialize(secondClass));
}
public void Should_match_on_the_name_even_if_values_match()
{
var source = new FirstClass
{
EnumValue = FirstEnum.NamedEnum
};
_result = Mapper.Map <FirstClass, SecondClass>(source);
_result.EnumValue.ShouldBe(SecondEnum.DifferentNamedEnum);
}
static void Main(string[] args)
{
var secondClass = new SecondClass();
Console.WriteLine(secondClass.Name);
var list = new List <int>();
var listNew = new CustomList <SecondClass>();
Console.ReadLine();
}
static void Main(string[] args)
{
var first = new FirstClass();
var second = new SecondClass();
var third = new ThirdClass();
var facade = new FacadeClass(first, second, third);
facade.ComfortableMethod();
}
public void Publish_WhenGivenEvent_ShouldTriggerFirstAndSecondClassObserver()
{
var f = new FirstClass();
var s = new SecondClass();
EventBus.Instance.Publish(new SampleEvent() { Status = 1 });
Assert.That(f.Status == "First Class received event! Status: 1");
Assert.That(s.Status == "Second Class received event! Status: 1");
}
public void Check02ChangedLoggerSetupOk()
{
//SETUP
GenericLibsBaseConfig.SetLoggerMethod = name => new Log4NetGenericLogger(name);
//ATTEMPT
var classWithLogger = new SecondClass();
//VERIFY
SecondClass.Logger.IsA <Log4NetGenericLogger>();
}
static void Main(string[] args)
{
IConsoleWritable someIConsoleWriteble;
someIConsoleWriteble = new FirstClass();
someIConsoleWriteble.WriteConsole();
someIConsoleWriteble = new SecondClass();
someIConsoleWriteble.WriteConsole();
Console.ReadLine();
}
protected TroopMember()
{
Scout = new Scout();
Tenderfoot = new Tenderfoot();
SecondClass = new SecondClass();
FirstClass = new FirstClass();
Star = new Star();
Life = new Life();
Eagle = new Eagle();
EaglePalms = new List <Palm>();
MeritBadges = new List <MeritBadge>();
}
public SecondClass Map(DbDataReader reader)
{
var result = new SecondClass();
result.LastName = reader.GetString(0);
result.FirstName = reader.GetString(1);
result.PersonId = reader.GetInt32(2);
result.CompanyId = reader.GetInt32(3);
result.RowVersion = (byte[])reader[4];
return(result);
}
public void CalculateRate()
{
FirstClass _firstClass = new FirstClass();
SecondClass _secondClass = new SecondClass();
ThirdClass _thirdClass = new ThirdClass();
FedEx _fedEx = new FedEx();
SPUFourD _fourD = new SPUFourD();
SPUTwoD _twoD = new SPUTwoD();
SPUNextD _nextD = new SPUNextD();
//first class
Assert.AreEqual(0.035, _firstClass.CalculateRate(1, 1), "Input: _firstClass.CalculateRate(1, 1)");
Assert.AreEqual(0.040, _firstClass.CalculateRate(1, 3), "Input: _firstClass.CalculateRate(1, 3)");
Assert.AreEqual(0.047, _firstClass.CalculateRate(1, 9), "Input: _firstClass.CalculateRate(1, 9)");
Assert.AreEqual(0.195, _firstClass.CalculateRate(1, 16), "Input: _firstClass.CalculateRate(1, 1)");
Assert.AreEqual(0.450, _firstClass.CalculateRate(1, 64), "Input: _firstClass.CalculateRate(1, 1)");
Assert.AreEqual(0.500, _firstClass.CalculateRate(1, 144), "Input: _firstClass.CalculateRate(1, 1)");
//second class
Assert.AreEqual(0.0035, _secondClass.CalculateRate(1, 1), "Input: _secondClass.CalculateRate(1, 1)");
Assert.AreEqual(0.0040, _secondClass.CalculateRate(1, 3), "Input: _secondClass.CalculateRate(1, 3)");
Assert.AreEqual(0.0047, _secondClass.CalculateRate(1, 9), "Input: _secondClass.CalculateRate(1, 9)");
Assert.AreEqual(0.0195, _secondClass.CalculateRate(1, 16), "Input: _secondClass.CalculateRate(1, 16)");
Assert.AreEqual(0.0450, _secondClass.CalculateRate(1, 64), "Input: _secondClass.CalculateRate(1, 64)");
Assert.AreEqual(0.0500, _secondClass.CalculateRate(1, 144), "Input: _secondClass.CalculateRate(1, 144)");
//third class
Assert.AreEqual(0.0020, _thirdClass.CalculateRate(1, 1), "Input: _thirdClass.CalculateRate(1, 1)");
Assert.AreEqual(0.0022, _thirdClass.CalculateRate(1, 3), "Input: _thirdClass.CalculateRate(1, 3)");
Assert.AreEqual(0.0024, _thirdClass.CalculateRate(1, 9), "Input: _thirdClass.CalculateRate(1, 9)");
Assert.AreEqual(0.0150, _thirdClass.CalculateRate(1, 16), "Input: _thirdClass.CalculateRate(1, 16)");
Assert.AreEqual(0.0160, _thirdClass.CalculateRate(1, 64), "Input: _thirdClass.CalculateRate(1, 64)");
Assert.AreEqual(0.0170, _thirdClass.CalculateRate(1, 144), "Input: _thirdClass.CalculateRate(1, 144)");
//fedex
Assert.AreEqual(20.00, _fedEx.CalculateRate(1, 16), "Input: _fedEx.CalculateRate(1, 16)");
Assert.AreEqual(23.00, _fedEx.CalculateRate(1, 64), "Input: _fedEx.CalculateRate(1, 64)");
Assert.AreEqual(25.00, _fedEx.CalculateRate(501, 16), "Input: _fedEx.CalculateRate(501, 16)");
Assert.AreEqual(28.00, _fedEx.CalculateRate(505, 50), "Input: _fedEx.CalculateRate(505, 50)");
//spu four day
Assert.AreEqual("$0.02", _fourD.CalculateRate(10, 5).ToString("c"), "Input: _fourD.CalculateRate(10, 5)");
Assert.AreEqual(.25, _fourD.CalculateRate(10, 80), "Input: _fourD.CalculateRate(10, 80)");
//spu two day
Assert.AreEqual("$0.16", _twoD.CalculateRate(10, 5).ToString("c"), "Input: _twoD.CalculateRate(10, 5)");
Assert.AreEqual(2.50, _twoD.CalculateRate(10, 80), "Input: _twoD.CalculateRate(10, 80)");
//spu next day
Assert.AreEqual("$0.23", _nextD.CalculateRate(10, 5).ToString("c"), "Input: _nextD.CalculateRate(10, 5)");
Assert.AreEqual(3.75, _nextD.CalculateRate(10, 80), "Input: _nextD.CalculateRate(10, 80)");
}
/// <summary>
/// Main entry point for the whole project.
/// </summary>
public void Initialize()
{
FirstClass firstClass = new FirstClass();
SecondClass secondClass1 = new SecondClass();
secondClass1.Name = "Petar";
secondClass1.Surname = "Petrovic";
SecondClass secondClass2 = new SecondClass("Petar;Petrovic");
SecondClass secondClass3 = new SecondClass(1, 2);
}
void Test()
{
BaseClass b = new BaseClass();
DerivedClass d = new DerivedClass();
SecondClass s = new SecondClass();
d.Name = "Pepita";
Name = "Manolito";
//can't because is protected
//b.Name = "Mielda";
//s.Name = "Jodel";
}
static void Main(string[] args)
{
Console.Write("Please enter the weight of the package: ");
double weight = Double.Parse(Console.ReadLine());
Console.Write("(P)ounds or (O)unces? ");
string unit = Console.ReadLine().ToLower();
if (unit == "p")
{
weight *= 16;
}
Console.Write("What distance will it be traveling? ");
int distance = Int32.Parse(Console.ReadLine());
List <IDeliveryDriver> rates = new List <IDeliveryDriver>();
FirstClass firstClass = new FirstClass();
SecondClass secondClass = new SecondClass();
ThirdClass thirdClass = new ThirdClass();
FedEx fedEx = new FedEx();
SPUFourD fourD = new SPUFourD();
SPUTwoD twoD = new SPUTwoD();
SPUNextD nextD = new SPUNextD();
rates.Add(firstClass);
rates.Add(secondClass);
rates.Add(thirdClass);
rates.Add(fedEx);
rates.Add(fourD);
rates.Add(twoD);
rates.Add(nextD);
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("\n{0, -30}{1, -30}", "Delivery Method", "$ cost");
Console.WriteLine("-------------------------------------");
foreach (var rate in rates)
{
Console.WriteLine("{0, -30}{1, -30}", rate.Name, rate.CalculateRate(distance, weight).ToString("c"));
}
Console.ReadKey();
}
/// <summary>
/// Factory Creator Method
/// </summary>
/// <param name="foctoryObjects">Factory Drive Class Enum</param>
/// <returns></returns>
public BaseClass CreateandReturnObj(FoctoryObjects foctoryObjects)
{
BaseClass baseObj = null;
switch (foctoryObjects)
{
case FoctoryObjects.First:
baseObj = new FirstClass();
break;
case FoctoryObjects.Second:
baseObj = new SecondClass();
break;
case FoctoryObjects.Thired:
baseObj = new ThiredClass();
break;
case FoctoryObjects.Forth:
baseObj = new ForthClass();
break;
}
return(baseObj);
}
static void Main(string[] args)
{
SecondClass sc = new SecondClass();
// P6
sc.P6(3, 12);
// P7
List <int> list = new List <int>();
list = sc.P7(2, 10);
foreach (int item in list)
{
Console.WriteLine("List: " + item);
}
Console.WriteLine();
// P8
Console.WriteLine(sc.P8(20040225));
Console.WriteLine();
// P9
Console.WriteLine(sc.P9(1789134502345L));
Console.WriteLine();
// P10
int[] arr = new int[sc.P10(1234567).Length];
arr = sc.P10(1234567);
foreach (int item in arr)
{
Console.Write(item);
}
Console.WriteLine();
}
public void MethodName1_DescriptionOfBehavior1_ExpectedResult1()
{
SecondClass classObj = new SecondClass();
Assert.AreEqual(typeof(SecondClass), classObj.GetType());
}
public FirstClass()
{
_TheField = new SecondClass();
}
public void Resolve_BySingle_SecondClass([Frozen] SecondClass secondClass, FirstClass firstClass)
{
Assert.Equal(firstClass.GetSecondClass.GetMyInterface.Model.MyString, secondClass.GetMyInterface.Model.MyString);
Assert.Equal(firstClass.GetSecondClass.GetMyInterface.Model.MyInteger, secondClass.GetMyInterface.Model.MyInteger);
Assert.Equal(firstClass.GetSecondClass.Property, secondClass.Property);
}
public void Resolve_ByTransient_SecondClass(SecondClass secondClass, FirstClass firstClass)
{
Assert.NotEqual(firstClass.GetSecondClass.GetMyInterface.Model.MyString, secondClass.GetMyInterface.Model.MyString);
Assert.NotEqual(firstClass.GetSecondClass.GetMyInterface.Model.MyInteger, secondClass.GetMyInterface.Model.MyInteger);
Assert.NotEqual(firstClass.GetSecondClass.Property, secondClass.Property);
}
public static void Main(string[] args)
{
Shape rectangle = new Rectangle(2, 4);
rectangle.showArea();
Shape square = new Square(2);
square.showArea();
Console.WriteLine();
SecondClass sc = new SecondClass();
Console.WriteLine();
Thread tdA = new Thread(threadMethodA);
tdA.Start();
Thread tdB = new Thread(threadMethodB);
tdB.Start();
Thread tdC = new Thread(threadMethodC);
tdC.Start();
Console.WriteLine("Hit {0} to exit the program.", "[ENTER]");
Console.ReadKey();
}
