public static void Main(string[] args)
{
IDeveloperFactory factory = CreateDevBySpeciality("Java");
IDeveloper dev = factory.CreateDeveloper();
dev.writeCode();
}
static void Main(string[] args)
{
Developer juniorDeveloper = new Junior();
Developer middleDeveloper = new Middle();
Developer seniorDeveloper = new Senior();
Developer architectDeveloper = new Architect();
juniorDeveloper.Next = middleDeveloper;
middleDeveloper.Next = seniorDeveloper;
seniorDeveloper.Next = architectDeveloper;
IDeveloper chainStart = juniorDeveloper;
var tasks = new[] { "Code class from UML diagram",
"Design and code module",
"Review junior's code",
"Design project structure",
"Write a project using JavaScript" };
foreach (var task in tasks)
{
Console.WriteLine($"Task: {task}");
chainStart.Handle(task);
Console.WriteLine();
}
}
public Task <int> CreateDeveloper(IDeveloper developer)
{
var developerModel = _mapper.Map <IDeveloper, Developer>(developer);
_uow.AddAsync(_mapper.Map <Developer, DeveloperEntity>(developerModel));
return(_uow.CommitAsync());
}
static void Main(string[] args)
{
IDeveloper[] workers = new IDeveloper[3];
Programmer Allan = new Programmer("Java");
Builder Tom = new Builder("hammer");
Programmer Lisa = new Programmer("C#");
workers[0] = Allan;
workers[1] = Tom;
workers[2] = Lisa;
foreach (var a in workers)
{
a.Create();
a.Destroy();
Console.WriteLine(a.Tool);
}
//sort by tool
Array.Sort(workers);
Console.WriteLine();
foreach (var a in workers)
{
Console.WriteLine(a.Tool);
}
}
static void TestDeveloper(IDeveloper developer)
{
Console.Write("Estimating: ");
developer.EstimateTime();
Console.Write("Engineering: ");
developer.WriteSoftware();
}
public static void Run()
{
IDeveloper developer = null;
var container = new CompositeContainer();
container.Configure();
developer = container.Resolve <IDeveloper>();
developer.Code();
}
public static void Run()
{
IDeveloper developer = null;
var container = new CompositeContainer(new CompositeRuntimeSettings {
Types = new[] { typeof(IDeveloper) }
});
container.Configure();
developer = container.Resolve <IDeveloper>();
Console.WriteLine(developer.Code());
}
public static void Run()
{
IDeveloper developer = null;
var container = new CompositeContainer(new CompositeRuntimeSettings {
Types = new[] { typeof(IDeveloper) }
});
container.Configure();
developer = container.Resolve <IDeveloper>();
Console.WriteLine("Each resolve creates a new instance: {0}", developer != container.Resolve <IDeveloper>());
}
public BsonDocument CreateDocument(IDeveloper developer)
{
if (developer == null)
{
return(null);
}
var doc = developer.ToBsonDocument();
return(doc);
}
public async Task <bool> DeleteAsync(IDeveloper entity)
{
var collection = MongoClientManager.DataBase.GetCollection <DeveloperModel>(CollectionNames.Developer);
var result = await collection.DeleteOneAsync(d => d.ID == entity.ID);
//check the document count
//var docs = await collection.Find(new BsonDocument()).ToListAsync();
//Console.WriteLine("document count: " + docs.Count);
return(result.DeletedCount == 1);
}
public static void Run()
{
IDeveloper developer = null;
var container = new CompositeContainer(new CompositeRuntimeSettings {
Types = new[] { typeof(IDeveloper) },
DependencyContainerAdapter = new StructureMapAdapter()
});
container.Configure();
developer = container.Resolve <IDeveloper>();
developer.Code();
}
public static void Run()
{
IDeveloper developer = null;
var container = new CompositeContainer(new CompositeRuntimeSettings {
Types = new[] { typeof(ICSharpDeveloper), typeof(IJavaScriptDeveloper) }
});
container.Configure();
developer = container.ResolveNamed <IDeveloper>("C#");
developer.Code();
developer = container.ResolveNamed <IDeveloper>("JavaScript");
developer.Code();
}
public int CompareTo(object obj)
{
IDeveloper temp = obj as IDeveloper;
if (temp != null)
{
return(this.Tool.CompareTo(temp.Tool));
}
else
{
throw new ArgumentException("Parameter is not Builder");
}
}
public async Task <int> UpdateDeveloper(int id, IDeveloper developer)
{
var dev = await _uow.Developers.GetDeveloperById(id);
if (dev != null)
{
var model = _mapper.Map <IDeveloper, Developer>(developer);
await _uow.UpdateAsync(_mapper.Map <Developer, DeveloperEntity>(model));
return(await _uow.CommitAsync());
}
return(await Task.FromResult(0));
}
public async static void Run()
{
IDeveloper developer = null;
var container = new CompositeContainer(new CompositeRuntimeSettings {
Types = new[] { typeof(IDeveloper) }
});
container.Configure();
SetHttpContext();
developer = container.Resolve <IDeveloper>();
Console.WriteLine("Instances within the same HttpContext are the same: {0}", developer == container.Resolve <IDeveloper>());
SetHttpContext();
Console.WriteLine("Instances within different HttpContext are not the same: {0}", developer != container.Resolve <IDeveloper>());
}
public static void Run()
{
IDeveloper developer = null;
Action <string> codeCompletionAction = (code) => Console.WriteLine(code);
var container = new CompositeContainer(new CompositeRuntimeSettings {
Types = new[] { typeof(IDeveloper) }
});
container.Configure();
developer = container.Resolve <IDeveloper>();
developer.OnCodeCompleted += codeCompletionAction;
developer.Code("C# coding");
developer.OnCodeCompleted -= codeCompletionAction;
}
public static void Run()
{
IDeveloper developer = null;
Func <string> handler = () => "C# coding";
var container = new CompositeContainer(new CompositeRuntimeSettings {
Types = new[] { typeof(IDeveloper) }
});
container.Configure();
developer = container.Resolve <IDeveloper>();
developer.OnCodeCompleted += handler;
developer.Code();
developer.OnCodeCompleted -= handler;
}
public async Task <IDeveloper> UpdateAsync(IDeveloper entity)
{
var collection = MongoClientManager.DataBase.GetCollection <IDeveloper>(CollectionNames.Developer);
await collection.ReplaceOneAsync(d => d.ID == entity.ID, entity);
Console.WriteLine("document added: " + entity.ToJson());
var filter = new BsonDocument();
Console.WriteLine("count:" + collection.Count(filter).ToString());
return(entity);
}
static void Main(string[] args)
{
Contractor c = new Contractor("contractor1", new[] { "python", "C#" });
Manager m = new Manager("manager1");
SoftwareDev s = new SoftwareDev("developer1", new[] { "java", "c#" });
Person[] people = new Person[] { c, m, s };
foreach (Person p in people)
{
if (p is Employee)
{
Employee e = (Employee)p;
//e.abstractMethod();
e.VirtualMethod();
// e.NormalMethod();
}
}
// people that do software development
foreach (Person p in people)
{
if (p is IDeveloper)
{
IDeveloper id = (IDeveloper)p;
Console.WriteLine($"{p.Name}: {string.Join(", ", id.Languages)}");
}
}
//python
foreach (Person p in people)
{
//IDeveloper id = (IDeveloper)p;
IDeveloper id = p as IDeveloper;
if (id != null && id.knows("python"))
{
Console.WriteLine(p.Name);
}
}
}
public async static Task Run()
{
IDeveloper developer = null;
bool sameInstanceAtEachThread = false;
IDeveloper otherThreadDeveloper = null;
var container = new CompositeContainer(new CompositeRuntimeSettings {
Types = new[] { typeof(IDeveloper) }
});
container.Configure();
otherThreadDeveloper = await Task.Factory.StartNew <IDeveloper>(() => {
var first = container.Resolve <IDeveloper>();
sameInstanceAtEachThread = container.Resolve <IDeveloper>() == first;
return(first);
});
developer = container.Resolve <IDeveloper>();
Console.WriteLine("Instance is created for each thread: {0}", otherThreadDeveloper != container.Resolve <IDeveloper>());
Console.WriteLine("All instances in the same thread are the same: {0}", sameInstanceAtEachThread && developer == container.Resolve <IDeveloper>());
}
static void Main(string[] args)
{
Team team = new Team();
team.Add(new Developer("Max"));
team.Add(new Developer("Alex"));
Team outerTeam = new Team();
outerTeam.Add(team);
outerTeam.Add(new Developer("Andrey"));
IDeveloper developer = outerTeam;
developer.Develop();
Console.WriteLine();
/* tests for composite + visitor
*
* developer.Accept(new AddingVisitor("Additional developer"));
*
* developer.Develop();
*/
}
static void Main(string[] args)
{
IDeveloper[] developers = new IDeveloper[4];
developers[0] = new Builder("Panel");
developers[1] = new Programmer("C#");
developers[2] = new Programmer("Java");
developers[3] = new Builder("Brick");
for (int i = 0; i < developers.Length; i++)
{
developers[i].Create();
}
for (int i = 0; i < developers.Length; i++)
{
developers[i].Destroy();
}
Console.WriteLine($"App built on the language: {developers[2].Tool}");
Console.WriteLine($"House was built from: {developers[3].Tool}");
for (int i = 0; i < developers.Length; i++)
{
Console.WriteLine(developers[i].Tool);
}
Array.Sort(developers);
Console.WriteLine("******Sorted array **********");
for (int i = 0; i < developers.Length; i++)
{
Console.WriteLine(developers[i].Tool);
}
Console.Read();
}
static void Main(string[] args)
{
IDeveloper[] developers = new IDeveloper[4];
Random rnd = new Random();
int random = 0;
for (int i = 0; i < developers.Length; i++)
{
random = rnd.Next(0, 2);
if (random == 0)
{
developers[i] = new Programmer();
}
else
{
developers[i] = new Builder();
}
}
foreach (var item in developers)
{
Console.WriteLine(item.Tool);
item.Create();
item.Destroy();
}
Array.Sort(developers);
foreach (var item in developers)
{
Console.WriteLine(item.Tool);
item.Create();
item.Destroy();
}
}
public UnityGame(IDeveloper developer) : base(developer)
{
}
public int CompareTo(IDeveloper obj)
{
return(Tool.CompareTo((obj as IDeveloper).Tool));
}
public DeveloperController(IDeveloper repository)
{
this.repository = repository;
}
public int CompareTo(object obj)
{
IDeveloper dev = (IDeveloper)obj;
return(_tool.CompareTo(dev.Tool));
}
public async Task <bool> Save(IDeveloper entity)
{
await _developerRepository.SaveAsync(entity);
return(true);
}
private static void PrintDeveloperName(IDeveloper developer)
{
Console.WriteLine(developer.Name);
}
public Customer(IDeveloper developer)
{
this.developer = developer;
}
public void Add(IDeveloper developer)
{
developers.Add(developer);
}