public void InheritanceSameColumnName()
{
using (var session = OpenSession())
using (var transaction = session.BeginTransaction())
{
var subClass = new SubClass();
var referencing = new ReferencingClass() { SubClass = subClass };
session.Save(subClass);
session.Save(referencing);
transaction.Commit();
}
using (var session = OpenSession())
using (var transaction = session.BeginTransaction())
{
var referencing = session.CreateQuery("from ReferencingClass")
.UniqueResult<ReferencingClass>();
// accessing a property of the base class to activate lazy loading
// this line crashes because it tries to find the base class by
// the wrong column name.
BaseClass another;
Assert.That(() => another = referencing.SubClass.Another, Throws.Nothing);
transaction.Commit();
}
}
public static void Main (string[] args) {
var sub = new SubClass();
BaseClass b = sub;
I1 i = sub;
sub.Write();
b.Write();
i.Write();
}
public static void Test2()
{
var s = new SubClass();
DoSomethingDelegate d1 = M.S;
DoSomethingDelegate d2 = s.S;
d1();
d2();
}
private void FindUpDown()
{
bool bFound = false;
// find the UpDown control
IntPtr pWnd = WIN32.GetWindow(this.Handle, WIN32.GW_CHILD);
while (pWnd != IntPtr.Zero)
{
//----------------------------
// Get the window class name
char[] className = new char[33];
int length = WIN32.GetClassName(pWnd, className, 32);
string s = new string(className, 0, length);
//----------------------------
if (s == "msctls_updown32")
{
bFound = true;
// not updown or Handle = 0 or handle = null, recreate one
if ((!bUpDown) || (scUpDown.Handle == IntPtr.Zero) || (scUpDown.Handle == null))
{
try
{
if (scUpDown.Handle != null)
{
scUpDown.DestroyHandle();
}
}
catch (Exception ex)
{
Console.Write(ex.Message);
}
//----------------------------
// Subclass it
this.scUpDown = new SubClass(pWnd, true);
this.scUpDown.SubClassedWndProc += new SubClass.SubClassWndProcEventHandler(scUpDown_SubClassedWndProc);
//----------------------------
//Update position
//UpdateUpDown();
bUpDown = true;
}
break;
}
pWnd = WIN32.GetWindow(pWnd, WIN32.GW_HWNDNEXT);
}
if ((!bFound) && (bUpDown))
{
bUpDown = false;
}
}
private void AddDefinitionSubClass(string subClassName, Class c)
{
var s = new SubClass(Definition.GenDataBase)
{
GenObject = CreateDefinitionSubClass(subClassName, (GenObject)c.GenObject)
};
c.SubClassList.Add(s);
}
public void TestMethod()
{
SubClass test = new SubClass();
PrivateObject privSub = new PrivateObject(test, new PrivateType(typeof(SubClass)));
PrivateObject privBase = new PrivateObject(test, new PrivateType(typeof(BaseClass)));
Assert.AreNotEqual <int>(0, (int)privBase.GetFieldOrProperty("one"));
Assert.AreNotEqual <int>(0, (int)privSub.GetFieldOrProperty("two"));
}
void itemImgSetter(int val, string imgPath)
{
switch (val)
{
case 0:
Gun1.Load(imgPath);
break;
case 1:
Gun2.Load(imgPath);
break;
case 2:
Gun3.Load(imgPath);
break;
case 3:
Head.Load(imgPath);
break;
case 4:
Arms.Load(imgPath);
break;
case 5:
Chest.Load(imgPath);
break;
case 6:
Legs.Load(imgPath);
break;
case 7:
ClassArmour.Load(imgPath);
break;
case 8:
Ghost.Load(imgPath);
break;
case 9:
Sparrow.Load(imgPath);
break;
case 10:
Ship.Load(imgPath);
break;
case 11:
SubClass.Load(imgPath);
break;
case 13:
Embelm.Load(imgPath);
break;
}
}
public SubClass CreateInstance(string key)
{
var val1 = GetVal1FromKey(key);
var val2 = GetVal2FromKey(key);
// create the actual instance of the subclass
var instance = new SubClass(val1, val2);
return(instance);
}
public List <Feature> FilterSubClassFeatures(SubClass sc, ClassDefinition cls, int classlevel, List <Feature> features, int level, IChoiceProvider provider, OGLContext Context)
{
if (sc != null && sc.MulticlassingSpellLevels != null && sc.MulticlassingSpellLevels.Count >= classlevel)
{
features.RemoveAll(f => f is SpellSlotsFeature);
features.AddRange(GetFeature("SUB_" + sc.Name, sc.MulticlassingSpellLevels[classlevel - 1]));
}
return(features);
}
static void Main()
{
// 声明类型为基类， 实际类型为子类
// 实际类型决定调用子类还是父类方法
BaseClass baseClass = new SubClass();
baseClass.VirtualMethod();
baseClass.AbstractMethod();
}
public void VerifyAddRemoveEventHandler5()
{
EventInfo ei = GetEventInfo(typeof(SubClass), "EventPublic");
Assert.NotNull(ei);
EventHandler myhandler = new EventHandler(MyEventHandler);
SubClass obj = new SubClass();
ei.AddEventHandler(obj, myhandler);
//Try to remove event Handler and Verify that no exception is thrown.
ei.RemoveEventHandler(obj, myhandler);
}
public void Override()
{
var baseClass = new BaseClass();
var subClass = new SubClass();
BaseClass subClassAsBaseClass = subClass;
QUnit.AreEqual(baseClass.Foo(), "base");
QUnit.AreEqual(subClass.Foo(), "sub");
QUnit.AreEqual(subClassAsBaseClass.Foo(), "sub");
}
public static void Main(string[] args)
{
var sub = new SubClass();
BaseClass b = sub;
I1 i = sub;
sub.Write();
b.Write();
i.Write();
}
static void Main(string[] args)
{
IBase instance1 = new SubClass <string>();
IBase instance2 = new SubClass <int>();
instance1.SomeMethod(); //this should call SomeMethod<string>()
instance2.SomeMethod(); //this should call SomeMethod<int>()
Console.ReadLine();
}
public static void Main(string[] args)
{
var obj = new SubClass() as BaseClass;
// obj IS SubClass type, but we are only going to use properties and methods
// available to ANY BaseClass
obj.BaseProp = 1; // this is fine
obj.ChildProp = 2; // this doesn't work (BaseClass does not contain a definition for ChildProp)
(obj as SubClass).ChildProp = 2; // this works
}
public void Override()
{
var baseClass = new BaseClass();
var subClass = new SubClass();
BaseClass subClassAsBaseClass = subClass;
AssertEquals(baseClass.Foo(), "base");
AssertEquals(subClass.Foo(), "sub");
AssertEquals(subClassAsBaseClass.Foo(), "sub");
}
public void InjectingSubClass_ShouldInjectInternalFieldInBaseClass()
{
_fixture.BindInstance(123);
var instance = new SubClass();
_fixture.Inject(instance);
Assert.That(instance.Value, Is.EqualTo(123));
}
public void SetSubClass(SubClass value)
{
if (value == null)
{
SubClassName = null;
}
else
{
SubClassName = value.Name + " " + ConfigManager.SourceSeperator + " " + value.Source;
}
}
public static uint CMPIsInst()
{
object o1 = new SubClass();
if ((o1 as Base) != null)
{
return(1);
}
return(0);
}
public static uint CMPObjectIsClass()
{
object o1 = new SubClass();
if (o1 is SubClass)
{
return(1);
}
return(0);
}
public void AMatchIsFound()
{
var baseObj = new ClassWithProperties();
var evaluated = new SubClass();
var fields = baseObj.GetInstanceFields();
var field = fields.First(n => n.Name.Equals("AField"));
var result = evaluated.HasFieldMatching(field);
Assert.True(result);
}
public void GetAttributes_FromObject()
{
var testValue = new SubClass();
var result = testValue.GetAttributes <CLSCompliantAttribute>();
Assert.IsNotNull(result);
Assert.IsTrue(result.Any());
var attr = result.First();
Assert.IsInstanceOfType(attr, typeof(CLSCompliantAttribute));
}
public async Task <IActionResult> Create([Bind("SubClassId,SubClassClassId,SubClassName,SubClassDescription,SubClassFeatures")] SubClass subClass)
{
if (ModelState.IsValid)
{
_context.Add(subClass);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(subClass));
}
public static Bitmap GetImage(this SubClass o)
{
if (o.ImageData == null)
{
return(null);
}
else
{
using (MemoryStream ms = new MemoryStream(o.ImageData)) return(new Bitmap(ms));
}
}
public void PatchOnArrayElementShouldRespectTypeOfSubclass()
{
var entity = new Entity
{
List = new List <BaseClassContainer>
{
new BaseClassContainer
{
BaseClass = new BaseClass
{
Name = "BaseClass1"
}
},
new BaseClassContainer
{
BaseClass = new BaseClass
{
Name = "BaseClass2"
}
}
}
};
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(entity);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
BaseClass newProperty = new SubClass
{
Name = "SubClass1"
};
session.Advanced.Patch <Entity, BaseClass>(entity.Id, x => x.List[0].BaseClass, (SubClass)newProperty);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var loadedEntity = session.Load <Entity>(entity.Id);
Assert.NotNull(loadedEntity.List[0].BaseClass as SubClass);
Assert.Equal("SubClass1", ((SubClass)loadedEntity.List[0].BaseClass).Name);
Assert.Equal(2, loadedEntity.List.Count);
Assert.Equal("BaseClass2", loadedEntity.List[1].BaseClass.Name);
}
}
}
private void ClassQuery(MajorClass mc, MajorClass mctemp, ISpatialFilter filter, IGeometry geo)
{
if (mc == null || filter == null || geo == null)
{
return;
}
string[] arrFc3DId = mc.Fc3D.Split(';');
if (arrFc3DId == null)
{
return;
}
foreach (SubClass sc in mc.SubClasses)
{
if (!sc.Visible3D)
{
continue;
}
bool bHave = false;
foreach (string fc3DId in arrFc3DId)
{
DF3DFeatureClass dffc = DF3DFeatureClassManager.Instance.GetFeatureClassByID(fc3DId);
if (dffc == null)
{
continue;
}
FacilityClass facc = dffc.GetFacilityClass();
IFeatureClass fc = dffc.GetFeatureClass();
if (fc == null || facc == null)
{
continue;
}
filter.WhereClause = "GroupId = " + sc.GroupId;
int count = fc.GetCount(filter);
if (count == 0)
{
continue;
}
bHave = true;
bHaveRes = true;
if (bHave)
{
break;
}
}
if (bHave)
{
SubClass sctemp = new SubClass(sc.Name, sc.GroupId, sc.Parent);
sctemp.Visible3D = sc.Visible3D;
mctemp.SubClasses.Add(sctemp);
}
}
}
public static void Main()
{
Console.WriteLine("Creating s");
SubClass s = new SubClass();
s.PrintSomething();
Console.WriteLine("\nCreating s1");
SubClass s1 = new SubClass(123);
s1.PrintSomething();
}
public void BaseClassTest()
{
RunTest(context =>
{
var a = new SubClass();
context.RunScript(string.Empty, a, @"
this.DoAThing(5);
this.DoSomething(10);
");
});
}
public void VerifyAddRemoveEventHandler5()
{
EventInfo ei = GetEventInfo(typeof(SubClass), "EventPublic");
Assert.NotNull(ei);
EventHandler myhandler = new EventHandler(MyEventHandler);
SubClass obj = new SubClass();
ei.AddEventHandler(obj, myhandler);
//Try to remove event Handler and Verify that no exception is thrown.
ei.RemoveEventHandler(obj, myhandler);
}
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
response = "";
Player player = Player.Get(((PlayerCommandSender)sender).SenderId);
if (!TrackingAndMethods.PlayersWithSubclasses.ContainsKey(player) ||
!TrackingAndMethods.PlayersWithSubclasses[player].Abilities.Contains(AbilityType.Bloodlust))
{
Log.Debug($"Player {player.Nickname} could not use the bloodlust command", Subclass.Instance.Config.Debug);
response = "";
return(true);
}
SubClass subClass = TrackingAndMethods.PlayersWithSubclasses[player];
if (TrackingAndMethods.OnCooldown(player, AbilityType.Bloodlust, subClass))
{
Log.Debug($"Player {player.Nickname} failed to use the bloodlust command", Subclass.Instance.Config.Debug);
TrackingAndMethods.DisplayCooldown(player, AbilityType.Bloodlust, subClass, "bloodlust", Time.time);
response = "";
return(true);
}
if (!TrackingAndMethods.CanUseAbility(player, AbilityType.Bloodlust, subClass))
{
TrackingAndMethods.DisplayCantUseAbility(player, AbilityType.Bloodlust, subClass, "bloodlust");
response = "";
return(true);
}
Scp207 scp207 = player.ReferenceHub.playerEffectsController.GetEffect <Scp207>();
byte prevIntensity = scp207.Intensity;
scp207.ServerChangeIntensity((byte)subClass.IntOptions["BloodlustIntensity"]);
scp207.ServerChangeDuration(subClass.FloatOptions["BloodlustDuration"], false);
TrackingAndMethods.PlayersBloodLusting.Add(player);
TrackingAndMethods.UseAbility(player, AbilityType.Bloodlust, subClass);
TrackingAndMethods.AddCooldown(player, AbilityType.Bloodlust);
Timing.CallDelayed(subClass.FloatOptions["BloodlustDuration"], () =>
{
if (TrackingAndMethods.PlayersBloodLusting.Contains(player))
{
TrackingAndMethods.PlayersBloodLusting.Remove(player);
}
scp207.ServerChangeIntensity(prevIntensity);
scp207.ServerChangeDuration(float.MaxValue, false);
});
return(true);
}
public static void Main(string[] strings)
{
SubClass sc1 = new SubClass(10);
SubClass sc2 = new SubClass(20);
MyFunc(sc1, sc2);
string s1 = "ani\u00ADmal";
object o1 = "animal";
Console.WriteLine("Comparison of '{0}' and '{1}': {2}", s1, o1, s1.CompareTo(o1));
}
public static bool Save(this SubClass s, Boolean overwrite)
{
s.Name = s.Name.Replace(ConfigManager.SourceSeperator, '-');
FileInfo file = SourceManager.GetFileName(s.Name, s.Source, Program.Context.Config.SubClasses_Directory);
if (file.Exists && (s.FileName == null || !s.FileName.Equals(file.FullName)) && !overwrite)
{
return(false);
}
using (TextWriter writer = new StreamWriter(file.FullName)) SubClass.Serializer.Serialize(writer, s);
s.FileName = file.FullName;
return(true);
}
public CsvMainClassMapping()
{
MapProperty(0, x => x.Property1);
MapUsing((entity, values) =>
{
var subClass = new SubClass();
subClass.Property2 = values.Tokens[1];
subClass.Property3 = values.Tokens[2];
entity.SubClass = subClass;
});
}
void Start()
{
int firstInt;
//int secondInt;
otherOtherClass = otherClass;
firstInt = 8;
//secondInt = firstInt;
otherOtherClass.var = 7;
Debug.Log (otherClass.var);
Debug.Log (firstInt);
}
void FunC(SubClass _s, int _count)
{
_count--;
if (_count <= 0)
{
return;
}
else
{
FunC(_s, _count);
_s.x++;
}
}
public static void ClassExamples2Func()
{
// Getting specific with base constructor
SubClass sci = new SubClass(1);
SubClass scs = new SubClass("test");
scs.MyFunc();
// Getting specific with base constructor
SubSubClass ssci = new SubSubClass(1);
SubSubClass sscs = new SubSubClass("test");
sscs.MyVirtualFunc();
}
public static uint CMPObjectIsClass ()
{
object o1 = new SubClass ();
if (o1 is SubClass)
return 1;
return 0;
}
public static uint CMPCastClass ()
{
object o1 = new SubClass ();
uint result = 1;
try {
Base b = (Base)o1;
} catch (System.InvalidCastException) {
result = 0;
}
return result;
}
public DestClass()
{
List = new List<string>();
Sub = new SubClass();
Title = "Hello";
}
public static void Main(string[] args)
{
var config = new MongoConfigurationBuilder();
// COMMENT OUT FROM HERE
config.Mapping(mapping =>
{
mapping.DefaultProfile(profile =>
{
profile.SubClassesAre(t => t.IsSubclassOf(typeof(MyClass)));
});
mapping.Map<MyClass>();
mapping.Map<SubClass>();
});
// TO HERE
config.ConnectionString("Server=127.0.0.1");
using (Mongo mongo = new Mongo(config.BuildConfiguration()))
{
mongo.Connect();
try
{
var db = mongo.GetDatabase("TestDb");
var collection = db.GetCollection<MyClass>();
MyClass square = new MyClass()
{
Corners = 4,
Name = "Square"
};
MyClass circle = new MyClass()
{
Corners = 0,
Name = "Circle"
};
SubClass sub = new SubClass()
{
Name = "SubClass",
Corners = 6,
Ratio = 3.43
};
collection.Save(square);
collection.Save(circle);
collection.Save(sub);
var superclass = (from item in db.GetCollection<MyClass>("MyClass").Linq()
where item.Corners > 1
select item.Corners).ToList();
var subclass = (from item in db.GetCollection<SubClass>("MyClass").Linq()
where item.Ratio > 1
select item.Corners).ToList();
Console.WriteLine("Count by LINQ on typed collection: {0}", collection.Linq().Count(x => x.Corners > 1));
Console.WriteLine("Count by LINQ on typed collection2: {0}", db.GetCollection<SubClass>().Linq().Count(x => x.Corners > 1));
//Console.WriteLine("Count by LINQ on typed collection3: {0}", db.GetCollection<SubClass>().Count(new { Corners = Op.GreaterThan(1) }));
Console.WriteLine("Count on typed collection: {0}", collection.Count(new { Corners = Op.GreaterThan(1) }));
var coll = db.GetCollection("MyClass");
var count = coll.Count(new Document("Corners", Op.GreaterThan(1)));
Console.WriteLine("Count: {0}", count);
Console.ReadKey();
}
finally
{
mongo.Disconnect();
}
}
//var main = new MainClass();
//main.Setup();
//main.Run();
}
private void FindUpDown()
{
bool bFound = false;
// find the UpDown control
IntPtr pWnd = Win32.GetWindow(this.Handle, Win32.GW_CHILD);
while (pWnd != IntPtr.Zero)
{
//----------------------------
// Get the window class name
char[] className = new char[33];
int length = Win32.GetClassName(pWnd, className, 32);
string s = new string(className, 0, length);
//----------------------------
if (s == "msctls_updown32")
{
bFound = true;
if (!bUpDown)
{
//----------------------------
// Subclass it
this.scUpDown = new SubClass(pWnd, true);
this.scUpDown.SubClassedWndProc += new SubClass.SubClassWndProcEventHandler(scUpDown_SubClassedWndProc);
//----------------------------
bUpDown = true;
}
break;
}
pWnd = Win32.GetWindow(pWnd, Win32.GW_HWNDNEXT);
}
if ((!bFound) && (bUpDown))
bUpDown = false;
}
public void IsInstanceOfType()
{
var subClass = new SubClass();
var baseClass = typeof(TestClass);
AssertTrue(baseClass.IsInstanceOfType(subClass));
}
public static uint CMPIsInst ()
{
object o1 = new SubClass ();
if ((o1 as Base) != null)
return 1;
return 0;
}
public static void Main ()
{
SubClass sc = new SubClass ();
}
public void EventTest01()
{
SubClass c = new SubClass();
c.EventTest += () => Console.WriteLine("Fired.");
c.Fire();
}
