public void TestCreateAbstractClass()
{
var c = new AbstractClass();
Assert.IsNotNull(c);
c.Name = "Tom";
Assert.AreEqual("Tom", c.Name);
}
public void TestCreateAbstractClass()
{
var c = new AbstractClass();
Assert.IsNotNull(c);
c.Name = "Tom";
Assert.AreEqual("Tom", c.Name);
}
public StudyPage()
{
InitializeComponent();
#region AnimationsInit
Task.WhenAll(
CSharpDef.FadeTo(0, 1),
definitions.FadeTo(0, 1),
progLang.FadeTo(0, 1),
OOP.FadeTo(0, 1),
DotNETFramework.FadeTo(0, 1),
clr.FadeTo(0, 1),
cls.FadeTo(0, 1),
cts.FadeTo(0, 1),
MSIL.FadeTo(0, 1),
JIT.FadeTo(0, 1),
Compiler.FadeTo(0, 1),
SourceCode.FadeTo(0, 1),
ExecutableCode.FadeTo(0, 1),
boxview1.FadeTo(0, 1),
generalProgTerms.FadeTo(0, 1),
Variables.FadeTo(0, 1),
DataType.FadeTo(0, 1),
Keywords.FadeTo(0, 1),
Operators.FadeTo(0, 1),
Expression.FadeTo(0, 1),
TypeCasting.FadeTo(0, 1),
Arrays.FadeTo(0, 1),
Function.FadeTo(0, 1),
Class.FadeTo(0, 1),
Object.FadeTo(0, 1),
Constructor.FadeTo(0, 1),
Destructor.FadeTo(0, 1),
Namespaces.FadeTo(0, 1),
Exceptions.FadeTo(0, 1),
ExceptionHandling.FadeTo(0, 1),
boxview2.FadeTo(0, 1),
oopProgTerms.FadeTo(0, 1),
Inheritance.FadeTo(0, 1),
BaseClass.FadeTo(0, 1),
DerivedClass.FadeTo(0, 1),
AbstractClass.FadeTo(0, 1),
MultilevelInheritance.FadeTo(0, 1),
HierarchicalInheritance.FadeTo(0, 1),
SingleInheritance.FadeTo(0, 1),
Interface.FadeTo(0, 1),
Polymorphism.FadeTo(0, 1),
Overriding.FadeTo(0, 1),
Encapsulation.FadeTo(0, 1),
Abstraction.FadeTo(0, 1),
Overloading.FadeTo(0, 1));
#endregion
// App.adCounter = 0;
}
public virtual void OnTriggerEnter2D(Collider2D collider)
{
AbstractClass ac = collider.GetComponent <AbstractClass> ();
if (ac)
{
ac.damage(damage, AbstractDamageCollider.DamageType.light, knockback);
destroy();
}
}
public void ObjectFromAbstractClass()
{
TeenyKernel kernel = new TeenyKernel();
kernel.Bind <AbstractClass>().To <ConcreteClass>();
AbstractClass test3 = kernel.Get <AbstractClass>();
Assert.IsNotNull(test3);
Assert.AreEqual(test3.Test(), "Hello World!");
}
private double ExecuteAbstractClass(AbstractClass something)
{
var stopwatch = Stopwatch.StartNew();
something.Execute();
stopwatch.Stop();
var ticks = stopwatch.ElapsedTicks;
var nanoseconds = GetNanoseconds(ticks);
return nanoseconds;
}
override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
AbstractClass c = animator.GetComponent <AbstractClass>();
if (c == null)
{
c = animator.transform.parent.GetComponent <AbstractClass>();
}
c.playSound(AbstractClass.sfx.kick, false);
}
static void Main(string[] args)
{
//模版方法设计模式
AbstractClass ac = null;
ac = new Concreateone();
ac.TemplateMethod();
ac = new ConcreateClassTwo();
ac.TemplateMethod();
Console.Read();
}
public bool Equals(AbstractClass other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(other.SomeProp == SomeProp);
}
private double ExecuteAbstractClass(AbstractClass something)
{
var stopwatch = Stopwatch.StartNew();
something.Execute();
stopwatch.Stop();
var ticks = stopwatch.ElapsedTicks;
var nanoseconds = GetNanoseconds(ticks);
return(nanoseconds);
}
protected async override void OnAppearing()
{
#region AnimationsFadeIn
await Task.WhenAll(
CSharpDef.FadeTo(1, 500),
definitions.FadeTo(1, 500),
progLang.FadeTo(1, 500),
OOP.FadeTo(1, 500),
DotNETFramework.FadeTo(1, 500),
clr.FadeTo(1, 500),
cls.FadeTo(1, 500),
cts.FadeTo(1, 500),
MSIL.FadeTo(1, 500),
JIT.FadeTo(1, 500),
Compiler.FadeTo(1, 500),
SourceCode.FadeTo(1, 500),
ExecutableCode.FadeTo(1, 500),
boxview1.FadeTo(1, 500),
generalProgTerms.FadeTo(1, 500),
Variables.FadeTo(1, 500),
DataType.FadeTo(1, 500),
Keywords.FadeTo(1, 500),
Operators.FadeTo(1, 500),
Expression.FadeTo(1, 500),
TypeCasting.FadeTo(1, 500),
Arrays.FadeTo(1, 500),
Function.FadeTo(1, 500),
Class.FadeTo(1, 500),
Object.FadeTo(1, 500),
Constructor.FadeTo(1, 500),
Destructor.FadeTo(1, 500),
Namespaces.FadeTo(1, 500),
Exceptions.FadeTo(1, 500),
ExceptionHandling.FadeTo(1, 500),
boxview2.FadeTo(1, 500),
oopProgTerms.FadeTo(1, 500),
Inheritance.FadeTo(1, 500),
BaseClass.FadeTo(1, 500),
DerivedClass.FadeTo(1, 500),
AbstractClass.FadeTo(1, 500),
MultilevelInheritance.FadeTo(1, 500),
HierarchicalInheritance.FadeTo(1, 500),
SingleInheritance.FadeTo(1, 500),
Interface.FadeTo(1, 500),
Polymorphism.FadeTo(1, 500),
Overriding.FadeTo(1, 500),
Encapsulation.FadeTo(1, 500),
Abstraction.FadeTo(1, 500),
Overloading.FadeTo(1, 500));
#endregion
}
private LoadedDocument CreateLoadedDocument(AbstractClass @class, string namespaceName)
{
if (!IsConstructorTest)
{
@class.Constructors.Clear();
if (!IsNestedConstructorTest)
{
RemoveNestedConstructors(@class.Constructors, @class.Classes, @class.Structs);
}
}
return(CreateLoadedDocument(@class, namespaceName, classes => classes.AbstractClasses.Add(@class)));
}
protected override void RenderEntityClass(AbstractClass <EntityNode> ac)
{
RenderNode(ac.Namespace);
_indentLevel++;
WriteIndented($"public class {ac.Name}");
WriteIndented("{");
_indentLevel++;
RenderNodes <BaseProperty>(ac.Properties);
_indentLevel--;
WriteIndented("}");
_indentLevel--;
WriteIndented("}");
}
public void OnTriggerEnter2D(Collider2D collider)
{
if (collider.gameObject == _target && collider.tag != "AllyHazard")
{
// Only damage the target.
AbstractClass ac = collider.GetComponent <AbstractClass> ();
if (ac)
{
ac.damage(_damage, AbstractDamageCollider.DamageType.medium, _knockback);
_anim.SetTrigger("Die");
parrotState = ParrotState.die;
}
}
}
public void CanInterceptAbstractClassWithVirtualMethodInterceptor()
{
bool invoked = false;
IInterceptionBehavior interceptionBehavior =
new DelegateInterceptionBehavior((mi, next) => { invoked = true; return(mi.CreateMethodReturn(100)); });
AbstractClass instance =
Intercept.NewInstance <AbstractClass>(
new VirtualMethodInterceptor(),
new[] { interceptionBehavior });
int value = instance.DoSomething();
Assert.AreEqual(100, value);
Assert.IsTrue(invoked);
}
protected override void RenderApiClass(AbstractClass <ApiNode> ac)
{
_activeConfig = ac.Config;
RenderNode(ac.Namespace);
_indentLevel++;
WriteIndented($"public class {ac.Name}Client");
WriteIndented("{");
_indentLevel++;
RenderNodes <RootObject>(ac.TopOfClassExtra);
RenderNodes <BaseProperty>(ac.Properties);
RenderNode(ac.Constructor);
RenderNodes <AbstractFunction>(ac.Functions);
_indentLevel--;
WriteIndented("}");
_indentLevel--;
WriteIndented("}");
}
/// <summary>
/// Tests AbstractClass.cs
/// </summary>
public static void AbstractClass()
{
//Testing instance of child class.
ChildClassFromAbstract ccfa = new ChildClassFromAbstract(false, 2342);
ccfa.PrintVariableAndPropertyValues();
ccfa.ChildOwnMethod();
ccfa.AbstractMethod();
ccfa.VirtualMethod();
Console.WriteLine("--------------------------");
//casting child class to base class and test again the methods. After conversion the specific methods of the child class will be lost.
AbstractClass ac = (AbstractClass)ccfa;
ac.AbstractMethod();
ac.VirtualMethod();
}
public void TestMethod()
{
AbstractClass abc = null;
System.Type clazz = GetType();
string testName = abc.Name;
abc.Name = testName;
int a = 0;
int i = a;
AbstractClass.InnerAbstractClass inf = new AnonymousClassAbstractClass_InnerAbstractClass1(i, this);
int[] b = null;
bool ab = (a == System.Int32.MinValue) || (b == null);
int j = 0;
NUnit.Framework.Assert.AreEqual(i, j, "message :");
}
public override void OnTriggerEnter2D(Collider2D collider)
{
if (state == MermaidState.fly)
{
Debug.Log("What Did I Hit? " + collider.tag);
AbstractClass ac = collider.GetComponent <AbstractClass> ();
if (ac != null)
{
AbstractEnemyControl ec = collider.GetComponent <AbstractEnemyControl> ();
if (ec != null)
{
// Give pain and bounce.
ec.damage(damage, AbstractDamageCollider.DamageType.heavy, knockback);
//state = MermaidState.explode;
//explode ();
}
}
}
}
private ITypeInfo CreateNewTypeInfo(Type netType)
{
ITypeInfo type = null;
if (netType.IsAbstract)
{
type = new AbstractClass();
}
else if (netType.IsClass)
{
type = new Class();
}
else if (netType.IsInterface)
{
type = new Interface();
}
else if (netType.IsEnum)
{
type = new Enumeration();
}
type.Name = netType.Name;
type.Namespace = netType.Namespace;
return type;
}
protected abstract void RenderEntityClass(AbstractClass <EntityNode> ac);
internal PutChar(AbstractClass parent)
: base(parent)
{
}
public AbstractClassContructorParameter(AbstractClass abstractClass)
{
}
} // modiferDict -> key: MemberName as string. Value: int modifier
public Character(string name, string race, int str, int dex, int con, int intelligence, int wis, int cha, AbstractClass charClass, AbstractWeapon weapon, AbstractArmor armor, bool shield, int team, int level = 1)
{
Name = name;
Race = race;
Str = new Strength(str);
Dex = new Dexterity(dex);
Con = new Constitution(con);
Int = new Intelligence(intelligence);
Wis = new Wisdom(wis);
Cha = new Charisma(cha);
Class = new Fighter(level);
EquippedArmor = armor;
EquippedWeapon = weapon;
ShieldEquipped = shield;
CalculateHitPoints();
CalculateAC();
CalculateAttackBonus();
Team = team;
}
public void TargetRpcCantHaveParamAbstract(INetworkConnection monkeyCon, AbstractClass monkeys)
{
}
public static void ConcreteMethodB(AbstractClass caller)
{
//Huge code unrelated to this class
caller.AbstractMethodA();
}
/*
* Klientkoden kallar template-metoden för att utföra algoritmen
* Klienten behöver veta vilken konkret klass som används
*/
public static void ClientCode(AbstractClass abstractClass)
{
// ...
abstractClass.TemplateMethod(); // Denna metod ligger den enda som är synlig utåt och sitter på den abstrakta basklassen
// ...
}
static void Main(string[] args)
{
Console.WriteLine("-- ArrayList --");
ArrayListDemo AlDemo = new ArrayListDemo();
AlDemo.AddNew();
AlDemo.Display();
AlDemo.Sort();
Console.WriteLine("Sorted List.");
AlDemo.Display();
Console.WriteLine("-- Stack --");
StackDemo st = new StackDemo();
QueueDemo Q = new QueueDemo();
Console.WriteLine("-- Generic List --");
MyGeneric <string> gen = new MyGeneric <string>();
gen.AddItem("abc");
gen.AddItem("xyz");
Console.WriteLine(gen.GetItem());
Console.WriteLine(gen.GetItem(1));
Console.WriteLine("-- Exceptions --");
//UserDefinedException uexp = new UserDefinedException();
try
{
UserDefinedException.ThrowUserDefinedException();
}
catch (UserDefinedException ex)
{
Console.WriteLine("Exception : " + ex.Message);
}
try
{
UserDefinedException.ThrowUserDefinedException("New Message");
}
catch (UserDefinedException ex)
{
Console.WriteLine("Exception : " + ex.Message);
}
Console.WriteLine("\n-- Format Deemo --");
FormattingDemo.Display();
DisplayXMLContents();
MyList list = new MyList();
Console.WriteLine(list.ToString());
Console.WriteLine("-- AbstractClass static methos--");
Console.WriteLine(AbstractClass.Display("Hello"));
Console.WriteLine("-- Yield Example --");
foreach (int i in YieldExample.Power(2, 8))
{
Console.Write("{0} ", i);
}
//// Single Thread Example.
Console.WriteLine("\n\nSingle Thread Example.\n");
ThreadDemo thread1 = new ThreadDemo();
ThreadDemo thread2 = new ThreadDemo("FromMain");
Console.WriteLine("Single Thread Ended");
//// Single Thread Example.
Console.WriteLine("\n\nTwo Threads Example.\n");
TwoThreads twoThreads = new TwoThreads("Child#1", "Child#2");
Console.WriteLine("Two Threads Ended");
Console.ReadKey();
}
public static DesignPattern GetDesignPattern(AbstractClass element)
{
return DslModeling::DomainRoleInfo.GetLinkedElement(element, AbstractClassDomainRoleId) as DesignPattern;
}
public static void SetDesignPattern(AbstractClass element, DesignPattern newDesignPattern)
{
DslModeling::DomainRoleInfo.SetLinkedElement(element, AbstractClassDomainRoleId, newDesignPattern);
}
public static bool ProcessStaticAbstract(AbstractClass @abstract)
{
return(@abstract.AbstractMethod());
}
protected abstract void RenderApiClass(AbstractClass <ApiNode> ac);
// The client code calls the template method to execute the algorithm.
// Client code does not have to know the concrete class of an object it
// works with, as long as it works with objects through the interface of
// their base class.
public static void ClientCode(AbstractClass abstractClass)
{
// ...
abstractClass.TemplateMethod();
// ...
}
/// <summary>
/// The client code calls the template method to execute the algorithm.
/// Client code does not have to know the concrete class of an object it works with,
/// as long as it works with objects through the interface of their base class.
/// </summary>
/// <param name="abstractClass"></param>
private void ClientCode(AbstractClass abstractClass)
{
// ...
abstractClass.TemplateMethod();
// ...
}
/// <summary>
/// The client code calls the template method to execute the algorithm.
/// Client code does not have to know the concrete class of an object it works with,
/// as long as it works with objects through the interface of their base class.
/// </summary>
/// <param name="abstractClass">Abstract class.</param>
public static void ProcessSomething(AbstractClass abstractClass)
{
// Initial operations
abstractClass.TemplateMethod();
// Additional operations
}
public Complex(string s, decimal d, IMyInterface instance, AbstractClass abstractClass)
{
Instance = instance;
AbstractClass = abstractClass;
}
public void CmdCantHaveParamAbstract(AbstractClass monkeys)
{
}
/// <summary>
/// Constructor
/// Creates a DesignPatternHasAbstractClasses link in the same Partition as the given DesignPattern
/// </summary>
/// <param name="source">DesignPattern to use as the source of the relationship.</param>
/// <param name="target">AbstractClass to use as the target of the relationship.</param>
public DesignPatternHasAbstractClasses(DesignPattern source, AbstractClass target)
: base((source != null ? source.Partition : null), new DslModeling::RoleAssignment[]{new DslModeling::RoleAssignment(DesignPatternHasAbstractClasses.DesignPatternDomainRoleId, source), new DslModeling::RoleAssignment(DesignPatternHasAbstractClasses.AbstractClassDomainRoleId, target)}, null)
{
}
